Defining Methods

class Time:
    """Represents the time of day."""

def print_time(time):
    s = f'{time.hour:02d}:{time.minute:02d}:{time.second:02d}'
    print(s)
       

To make print_time a method, all we have to do is move the function definition inside the class definition. Notice the change in indentation.

At the same time, we’ll change the name of the parameter from time to self. This change is not necessary, but it is conventional for the first parameter of a method to be named self:

class Time:
    """Represents the time of day."""    

    def print_time(self):
        s = f'{self.hour:02d}:{self.minute:02d}:{self.second:02d}'
        print(s)
       

To call this function, you have to pass a Time object as an argument. Here’s the function we’ll use to make a Time object:

def make_time(hour, minute, second):
    time = Time()
    time.hour = hour
    time.minute = minute
    time.second = second
    return time
       

And here’s a Time instance:

start = make_time(9, 40, 0)
       

There are two ways to call print_time. The first (and less common) way is to use function syntax:

Time.print_time(start)
       

09:40:00
       

In this version, Time is the name of the class, print_time is the name of the method, and start is passed as a parameter. The second (and more idiomatic) way is to use the method syntax:

start.print_time()
       

09:40:00
       

Another Method

start.time_to_int()
       

34800
       

It is common to say that we “call” a function and “invoke” a method, but they mean the same thing.

Static Methods

end = start.add_time(1, 32, 0)
print_time(end)
        

11:12:00
        

Comparing Time Objects

%%add_method_to Time

    def __str__(self):
        s = f'{self.hour:02d}:{self.minute:02d}:{self.second:02d}'
        return s
        

The __init__ Method

%%add_method_to Time

    def __init__(self, hour=0, minute=0, second=0):
        self.hour = hour
        self.minute = minute
        self.second = second
        

Now when we instantiate a Time object, Python invokes __init__, and passes along the arguments. So we can create an object and initialize the attributes at the same time:

time = Time(9, 40, 0)
print(time)
        

09:40:00
        

In this example, the parameters are optional, so if you call Time with no arguments, you get the default values:

time = Time()
print(time)
        

00:00:00
        

If you provide one argument, it overrides hour:

time = Time(9)
print(time)
        

09:00:00
        

If you provide two arguments, they override hour and minute:

time = Time(9, 45)
print(time)
        

09:45:00
        

And if you provide three arguments, they override all three default values.

When I write a new class, I almost always start by writing __init__, which makes it easier to create objects, and __str__, which is useful for debugging.

Operator Overloading

Here is an __add__ method:

%%add_method_to Time

    def __add__(self, other):
        seconds = self.time_to_int() + other.time_to_int()
        return Time.int_to_time(seconds)
        

We can use it like this:

duration = Time(1, 32)
end = start + duration
print(end)
        

11:12:00
        

There is a lot happening when we run these three lines of code:

Changing the behavior of an operator so that it works with programmer-defined types is called operator overloading. For every operator, like +, there is a corresponding special method, like __add__.

Debugging

%%add_method_to Time

    def is_valid(self):
        if self.hour < 0 or self.minute < 0 or self.second < 0:
            return False
        if self.minute >= 60 or self.second >= 60:
            return False
        if not isinstance(self.hour, int):
            return False
        if not isinstance(self.minute, int):
            return False
        return True
        

Then, at the beginning of each method you can check the arguments to make sure they are valid:

%%add_method_to Time

    def is_after(self, other):
        assert self.is_valid(), 'self is not a valid Time'
        assert other.is_valid(), 'self is not a valid Time'
        return self.time_to_int() > other.time_to_int()
        

duration = Time(minute=132)
print(duration)
        

00:132:00
        

start.is_after(duration)
        

AssertionError: self is not a valid Time
        

assert statements are useful because they distinguish code that deals with normal conditions from code that checks for errors.

Exercises

def subtract_time(t1, t2):
    return time_to_int(t1) - time_to_int(t2)