Python Mini-Course

1
Lesson 28Classes and Methods

• Python Mini-Course
• University of Oklahoma
• Department of Psychology

2
Lesson objectives

1. Create methods inside class definitions
2. Call methods using function syntax and method
   syntax
3. Create custom __init__ and __str__ methods
4. Use operator overloading

3
Encapsulation

• Data and behaviors are packaged together
• The object only reveals the interfaces needed to
  interact with it
• Internal data and behaviors can remain hidden

4
Encapsulating the Time class

• Instead of using functions, we want to use
  methods
• Move the functions inside the class definition

5
The print_time() method

• class Time(object)
• def print_time(self)
• """
• Print the time in hourminutesecond
  format.
• """
• print '02d02d02d' \
• (self.hour, self.minute, self.second)

6
Calling a method

• Using function syntax
• t1 Time(2,35)
• Time.print_time(t1)
• Using method syntax
• t1.print_time()

7
Converting the other functions to methods

• The valid_time method
• The increment method
• The add_time method

8
The valid_time method

• class Time(object)
• ...
• def valid_time(self)
• validity True
• All values must be at least zero
• if self.hour lt 0 or self.minute lt 0 \
• or self.second lt 0
• validity False
• Minute and second must be base 60
• if self.minute gt 60 or self.second gt
  60
• validity False
• return validity

9
The increment method

• class Time(object)
• ...
• def increment(self, t2)
• Check the input arguments
• if type(t2) ! Time
• raise AttributeError, \
• 'invalid argument passed to
  Time.increment()'
• if not t2.valid_time()
• raise ValueError, \
• 'invalid Time object passed to
  Time.increment()'
• Add the times
• self.hour t2.hour
• self.minute t2.minute
• self.second t2.second

10
The add_time method

• class Time(object)
• ...
• def add_time(self, t2)
• Add the times
• new_time Time()
• new_time.hour self.hour t2.hour
• new_time.minute self.minute t2.minute
• new_time.second self.second t2.second
• Return the sum
• return new_time

11
Using the Time class

• t1 Time(0,0,30)
• t2 Time(1,0,45)
• t1.increment(t2)
• t1.print_time()
• t3 t1.add_time(t2)
• t3.print_time()
• t4 Time.add_time(t1, t2)
• t4.print_time()

12
Improving the Time class

• Problems
• Formatting
• Minutes and seconds should always be less than 60
• Printing is awkward
• Adding times is awkward
• Solutions see time_oop1.py

13
Keeping the right format

• class Time(object)
• ...
• def adjust_base_60(self)
• Increment minutes as necessary and
  adjust seconds
• self.minute self.second // 60
• self.second self.second 60
• Increment hours as necessary and adjust
  minutes
• self.hour self.minute // 60
• self.minute self.minute 60

14
Controlling access to attributes

• class Time(object)
• ...
• def set_time(self, hour0, minute0,
  second0)
• self.hour hour
• self.minute minute
• self.second second
• self.adjust_base_60()

15
The __str__ method

• class Time(object)
• def __str__(self)
• """
• Return the time in hourminutesecond
  format.
• """
• return '02d02d02d' \
• (self.hour, self.minute, self.second)

16
The __str__ method

• The __str__ method is a special method that is
  called by the str() and print commands
• t1 Time(2,45)
• str(t1)
• print t1

17
Why does this work?

• In Python, the most basic class, the object
  class, defines the __str__ method
• Time is a sub-class of the object class, and it
  inherits this behavior
• By defining our own __str__ method we override
  the base class method
• This is polymorphism

18
Operator overloading

• We can also define how a class responds to
  standard operators such as , -, etc.
• This is called operator overloading

19
The __add__ method

• class Time(object)
• ...
• def __add__(self, other)
• return self.add_time(other)
• def add_time(self, t2)
• new_time Time()
• new_time.hour self.hour t2.hour
• new_time.minute self.minute t2.minute
• new_time.second self.second t2.second
• new_time.adjust_base_60()
• return new_time

20
Using the __add__ method

• t1 Time(0,0,30)
• t2 Time(1,0,45)
• t3 t1 t2
• print t3
• print t1 t2

21
Type-based dispatch

• Allow us to use different types of arguments for
  the same method (or function)

22

• class Time(object)
• ...
• def increment(self, t2)
• Check the input arguments
• if type(t2) Time
• Add the times
• self.hour t2.hour
• self.minute t2.minute
• self.second t2.second
• elif type(t2) int
• Increment the seconds
• self.second t2
• else
• raise AttributeError, \
• 'invalid argument passed to
  Time.increment()'
• self.adjust_base_60()

23
For more practice, try

• Think Python. Chap 17
• Exercise 17.3, page 165
• Exercise 17.4, page 166
• Exercise 17.5, page 167
• Exercise 17.6, page 169 (debugging exercise)

24
Assignment

• Think Python. Chap 18
• Read text
• Type in and run code as you go (save as poker.py)
• Do Exercises 18.2 and 18.3 in text