Tips and Examples

• Common Error: Class Test Code Does Not Run

Review

• Magic Methods
• Magic Methods and Boolean Operators
• Type Conversion Magic Methods
• More Relational Magic Methods
• Putting Test Code into Class Modules

New Material

• Reusing Classes
• Inheritance
• Principles of Inheritance
• An Example of Inheritance
• The Video Class
• The Video Constructor
• Validation Methods for Video
• Calculating the Collection Number
• The Updated Video Constructor
• Video Accessors
• The __str__ Method
• Creating Superclasses
• Honesty and Trust

Readings

In Chapter 11, Inheritance, from our textbook, Starting Out with Python, you should read sections 11.1 and 11.2, Introduction to Inheritance and Polymorphism.

Homework 10

I have posted homework 10 here.

Quiz 8

Let's look at the answers to Quiz 8.

Tips and Examples

Common Error: Class Test Code Does Not Run

• All class modules should contain test code
• The test code should be contained in the code block of the following if statement

  if __name__ == "__main__": 

• The module should be made executable

  chmod 755 MODULE_FILENAME

• You can run the test code by running the module
• If the test code does not run the problem is with the if statement
• Notice that the expression on the right side of the == operator is a string
• This string must be "__main__"
• Check that you have two _ on each side of "main"
• Also check that there are no spaces inside the quotes

Review

Magic Methods

• When we do calculations with numbers we can use operators

  x += 7
  y = x + 8
  x > y

• When we create objects we create methods that act on them
• The Time class has a difference method
• That gives the difference between two Time objects
• So if t1 and t2 are Time objects I can get the time between them like this

  diff = t1.difference(t2)

• But wouldn't it be better to be able to write

  diff = t1 - t2

• We can if we create a magic method
• For every arithmetic operator
• There is an equivalent magic method

  Operator	Magic Method
  +	__add__(self, other)
  -	__sub__(self, other)
  *	__mul__(self, other)
  //	__floordiv__(self, other)
  /	__truediv__(self, other)
  %	__mod__(self, other)
  **	__pow__(self, other)

• So if we wanted to know the difference between two Time objects
• All we have to do is change the name of the difference method
• To __sub__

  # returns the difference in seconds between two times
  def __sub__(self, other_time):
      return self.__seconds - other_time.__seconds

• Now we can simply use the subtraction operator,   -
• To tell the difference in seconds between two Time objects

  >>> t1 = Time("10:45:10")
  >>> t2 = Time("10:50:00")
  >>> t2 - t1
  290
  

• Magic methods allow us to work with objects
• The same way we work with numbers

Magic Methods and Boolean Operators

• Boolean operators are used to compare two things
• We can use magic methods to implement the boolean operators
• For any class we create
• Here they are

  Operator	Magic Method
  ==	__eq__(self, other)
  !=	__ne__(self, other)
  <	__lt__(self, other)
  >	__gt__(self, other)
  <=	__le__(self, other)
  >=	__ge__(self, other)

• Implementing these magic methods is straightforward

  def __eq__(self, other):
      return self.__seconds == other.__seconds
  
  def __ne__(self, other):
      return self.__seconds != other.__seconds
  
  def __lt__(self, other):
      return self.__seconds < other.__seconds
  
  def __gt__(self, other):
      return self.__seconds > other.__seconds
  
  def __le__(self, other):
      return self.__seconds <= other.__seconds
  
  def __ge__(self,other):
      return self.__seconds >= other.__seconds

• And they work as you would expect

  >>> t1 = Time("10:45:10")
  >>> t2 = Time("10:50:00")
  >>> t3 = Time("10:50:00")
  >>> t1 == t2
  False
  t2 == t3
  True
  >>> t1 < t2
  True
  >>> t1 > t2
  False
  >>> t1 <= t2
  True
  >>> t2 <= t3
  True
  >>> t1 >= t2
  False
  >>> t2 >= t3
  True

Type Conversion Magic Methods

• You can change the data type of a value
• By using one of Python's conversion functions
  • int
  • float
  • bool
  • str
• We can use these functions on an object variable of a class
• If we implement the appropriate magic method

  Operator	Magic Method
  int	__int__(self)
  float	__float__(self)
  bool	__bool__(self)
  str	__str__(self)

• We have already implemented __str__
• How we implement each of the other magic methods is up to us
• Since the __seconds attribute already stores an integer
• The simplest way to implement __int__ is just to return that value

  def __int__(self):
      return self.__seconds

• To turn an integer into a float we multiply by 1.0

  def __float__(self):
      return self.__seconds * 1.0

• But what about __bool__?
• In Python, any integer that is not zero is True

  >>> bool(0)
  False
  >>> bool(5)
  True
  >>> bool(-5)
  True

• So let's do the same for our __bool__ method

  def __bool__(self):
      return self.__seconds != 0

• Here is how they work

  >>> t1 = Time("10:15:00")
  >>> t2 = Time("00:00:00")
  >>> str(t1)
  '10:15:0 AM'
  >>> bool(t1)
  True
  >>> bool(t2)
  False
  >>> int(t1)
  36900
  >>> int(t2)
  0
  >>> float(t1)
  36900.0

• You will find the code for the latest version of the Time class here

More Relational Magic Methods

• When we created relational magic methods for the Time class
• We simply applied the normal relational operators
• To two integer second values

  def __eq__(self, other):
      return self.__seconds == other.__seconds

• But what if we have two objects
• That are not so easily compared?
• For example two Car objects?
• Let's say the Car class has the following attributes
  • __manufacturer
  • __model
  • __year
  • __color
• What makes two Car objects equal?
• Do all of the attributes have to be equal?
• This decision is up to the programmer
• We could say that two cars are equal
• If they had the same manufacturer and model

      def __eq__(self, other):
          return self.__manufacturer == other.get_manufacturer() and self.__model == other.get_model()
  
      def __ne__(self, other):
          return self.__manufacturer != other.get_manufacturer() or self.__model != other.get_model() 

• But that is only one possibility

Putting Test Code into Class Modules

• It is always a good idea to write test code for each class
• It is best to put the test code inside the class definition
• But if we simply add the code to the bottom of the file
• It will always be run when we import the class

  >>> from car4 import Car
  Honda CRV 1997 Blue
  Honda CRV 2010 Green
  Honda Civic 2015 Red
  c1 == c2 : True
  c1 == c3 : False
  c1 != c3 : True

• We can prevent this from happening
• We can put the test code in a special if statement

  if __name__ == "__main__":
      c1 = Car("Honda", "CRV",   "1997", "Blue")
      c2 = Car("Honda", "CRV",   "2010", "Green")
      c3 = Car("Honda", "Civic", "2015", "Red")
      print(c1)
      print(c2)
      print(c3)
      print("c1 == c2 :" , c1 == c2 )
      print("c1 == c3 :" , c1 == c3 )
      print("c1 != c3 :" , c1 != c3 )

• The code will be executed if we run the class at the command line

  $ ./car3.py 
  Honda CRV 1997 Blue
  Honda CRV 2010 Green
  Honda Civic 2015 Red
  c1 == c2 : True
  c1 == c3 : False
  c1 != c3 : True

• But not when we import it

  >>> from car3 import Car
  >>> 

New Material

Reusing Classes

• Why create a class?
• If you want to do something once and never again
• Classes are not worth the bother
• You create classes for things you want to use over and over
• It was work to create the Student class
• But I can use it in many of the scripts I write
• But there is another advantages to using classes
• If you have created a class for one thing
• You can use it to create another class for something similar
• This feature is called inheritance

Inheritance

• Inheritance lets lets you use the attributes and methods of one class
• To create another class
• Say you were a biologist studying the evolution of life
• Biologists divide all living things into separate categories
• That are called kingdoms
• There are six kingdoms
  • Eubacteria - Normal bacteria
  • Archaebacteria - Very old bacteria
  • Protists - Various microscopic organisms
  • Fungi - Fungi and yeasts
  • Plants - Plants
  • Animals - Animals
• You can see a nice summary of the different kingdoms here
• To create Python code to work with all living things
• We would probably first create a class called Organism
• It would contain the two parts of the scientific name
  • Genus name
  • Species name
• And maybe a picture of the organism
• Perhaps also its DNA sequence
• Then we would use this class to create classes for each kingdom
• Each class would have methods and attributes appropriate
• For a living thing of one kingdom

Principles of Inheritance

• Where should we use inheritance?
• Inheritance does not work where two things are very different
• It only works when there is an "is a" relationship between them
• An animal is certainly an organism
• So we could create create an Animal class based on Organism
• Whenever we use one class as the basis of another class
• We call the original class the superclass or the base class
• The class which inherits is called the subclass or derived class
• A subclass inherits all the attributes and methods of its superclass

An Example of Inheritance

• The science of classifying the living things is called taxonomy
• And is not something I know a great deal about
• It would be hard for me to use it as example of inheritance
• So instead I will pick something from my own life
• I have over 500 DVDs of various types
• Some are movies
• Others are television series such as Mythbusters and Nova
• I also have video lectures that I buy from The Great Courses
• I need to store different information for each type of video
• For example, a Great Courses Video always contains 6 lessons
• Which are taught by an instructor
• Movies always have a director
• But TV series do not

The Video Class

• Let's start out by creating the superclass called Video
• It will have the following attributes
  • Collection number
  • Name
  • Length
  • Format
• The collection number is a unique number assigned to each video
• The first video has a collection number of 1
• The length is the running time in minutes
• So it must be an integer
• The format can either be "DVD" or "Blue Ray"
• None of these values will change after they have been entered
• So we will need accessors
• But no mutators
• We will also need a constructor

The Video Constructor

• There are only 4 attributes in the Video class
• So you might think the constructor would be

  def __init__(self, collection_no, name, length, format):
      self.__collection_no = collection_no
      self.__name   = name
      self.__length = length
      self.__format = format

• But this constructor does no data validation
• I don't want length to be a string like "foo"
• And the value of format must be either "DVD" or "Blue Ray"
• So we need to create some validation methods
• In addition each collection number should be one more than the previous

Validation Methods for Video

• Although there are 4 attributes in the Video class
• The constructor will only require three values
  • Name
  • Length
  • Format
• The value for __collection_no must be calculated
• I will deal with that in the next section
• We need to know the possible values for each attribute
• Before we can can create its validation function
• They are
  • Name - a string of at least 3 characters that are letters or digits
  • Length - an integer ranging from 15 to 1000
  • Format - "DVD" or "Blue Ray"
• __check_name counts the number of characters in the name parameter
• It will only count letters or digits
• Not spaces or symbols
• We can do this in a for loop using the string method isalnum
• If if there are too few characters we raise a ValueError exception
• But how do I specify the minimum number of legal characters?
• I don't want to use the integer literal 3
• Since I might want to change my mind later
• Instead I'll create a global variable MIN_NAME_LENGTH
• It must be defined outside the class
• Here is the code

  MIN_NAME_LENGTH = 3
  
  class Video:
  ...
  
      def __check_name(self, name):
          if type(name) is not str:
              raise TypeError("Video constructor expects a string argument for name")
          char_count = 0
          for char in name:
              if char.isalnum():
                  char_count += 1
          if char_count < MIN_NAME_LENGTH:
              raise ValueError("Name must have at least " + str(MIN_NAME_LENGTH) + \
                      " characters that are letters or digits")

• Which I test as follows

  >>> v1 = Video(0, 0, "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/Documents/workspace-neon/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 11, in __init__
      self.__check_name(name)
    File "/Users/glenn/Documents/workspace-neon/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 21, in __check_name
      raise TypeError('Video constructor expects a string argument for name')
  TypeError: Video constructor expects a string argument for name
  >>> 
  >>> v1 = Video("he", 0, "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/Documents/workspace-neon/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 11, in __init__
      self.__check_name(name)
    File "/Users/glenn/Documents/workspace-neon/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 28, in __check_name
      ' characters that are letters or digits')
  ValueError: Name must have at least 3 characters that are letters or digits
  >>> 
  >>> v1 = Video("he o", 0, "foo")
  >>> 

• The value for length must be an integer between 15 and 1000
• Again I will use global variables for the minimum and maximum
• Here is the code

  MIN_LENGTH      = 15
  MAX_LENGTH      = 1000
  
  class Video:
  ...
      def __check_length(self, length): 
          if type(length) is not int:
              raise TypeError("Video constructor expects a integer argument for length")
          if length < MIN_NAME_LENGTH or length > MAX_LENGTH:
              raise ValueError("Length must be at least " + str(MIN_LENGTH) + 
                  " and no more than " + str(MAX_LENGTH))

• And testing shows it works

  >>> v1 = Video("Forbidden Planet", "foo", "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 13, in __init__
      self.__check_length(length)
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 30, in __check_length
      raise TypeError('Video constructor expects a integer argument for length')
  TypeError: Video constructor expects a integer argument for length
  >>> 
  >>> v1 = Video("Forbidden Planet", 0, "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 13, in __init__
      self.__check_length(length)
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 33, in __check_length
      " and no more than " + str(MAX_LENGTH))
  ValueError: Length must be at least 15 and no more than 1000
  >>> 
  >>> v1 = Video("Forbidden Planet", 2000, "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 13, in __init__
      self.__check_length(length)
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 33, in __check_length
      ' and no more than ' + str(MAX_LENGTH))
  ValueError: Length must be at least 15 and no more than 1000
  >>> 
  >>> v1 = Video("Forbidden Planet", 100, "foo")
  >>> 

• The last validation method is the simplest
• All I have to do is check that format is "DVD" or "Blue Ray"
• But again, I might want to allow other formats in the future
• So I will create the global variable FORMATS
• It will be a tuple of all valid format strings
• Here is the code

  FORMATS         = ("DVD", "Blue Ray")
  
  class Video:
  ...
      def __check_format(self, format):
          if type(format) is not str:
              raise TypeError("Video constructor expects a string argument for format")
          if format not in FORMATS:
              raise ValueError("Format must be one of " + str(FORMATS))

• And here is the test

  >>> v1 = Video("Forbidden Planet", 100, "foo")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 15, in __init__
      self.__check_format(format)
    File "/Users/glenn/workspace-mars/it117/resources_it117/code_it117/example_code_it117/11_chapter_example_code/video.py", line 39, in __check_format
      raise ValueError('Format must be one of ' + str(FORMATS))
  ValueError: Format must be one of ('DVD', 'Blue Ray')
  >>> 
  >>> v1 = Video("Forbidden Planet", 100, "DVD")
  >>> 

Calculating the Collection Number

• We want __collection_no to start with 1
• And advance by 1 with each new entry
• There is no reason the user should be asked to do this
• Instead it should be calculated automatically
• We will store the collection number of the last video entered
• This value will initially be set to zero
• And it will be incremented for each new video
• But where are we going store this value?
• The easiest thing to do is store it in a file on disk
• We'll keep the filename in the global variable FILENAME
• __next_collection_no will
  • Read the number from disk
  • Increment the number by 1
  • Store the new number on disk
  • Return the new number
• We run open function inside a try block
• If the file does not exist we will
  • Set the collection number to 1
  • Write the number to disk
  • Return it to the calling function
• We'll store the number on disk as a string
• To keep things simple
• Here is the code

  # reads the last collection number used from a file,
  # increments that number and writes it back to the file
  # and returns the incremented number
  def __next_collection_no(self):
      try:
          file = open(FILENAME, 'r')
          collection_no = int(file.readline())
          collection_no += 1
          file.close()
      except FileNotFoundError:
          collection_no = 1
      finally:
          file = open(FILENAME, 'w')
          file.write(str(collection_no))
          file.close()
          return collection_n

The Updated Video Constructor

• We can use these functions in a new version of the constructor
• First we run the validation methods
• In the oder that the attributes appear in the constructor
• If the parameters pass the tests we assign them to the attributes

  def __init__(self, name, length, format):
      self.__check_name(name)
      self.__check_length(length)
      self.__check_format(format)
      self.__collection_no = self.__next_collection_no()
      self.__name   = name
      self.__length = length
      self.__format = format

• Testing the results we get

  >>> from video import Video
  >>> v1 = Video("Forbidden Planet", 100, "DVD")
  >>> v1.get_collection_no()
  1
  >>> v2 = Video("The Day the Earth Stood Stil", 90, "DVD")
  >>> v2.get_collection_no()
  2

Video Accessors

• Now we need accessors for each of the attributes

  def get_collection_no(self):
      return self.__collection_no
  
  def get_name(self):
      return self.__name
  
  def get_length(self):
      return self.__length
  
  def get_format(self):
      return self.__format

• Now we need to test them

  >>> v1 = Video("Forbidden Planet", 100, "DVD")
  >>> v1.get_collection_no()
  1
  >>> v1.get_name()
  'Forbidden Planet'
  >>> v1.get_length()
  100
  >>> v1.get_format()
  'DVD'

The __str__ Method

• We need one more method before we leave this class
• We need to create a __str__ method
• This method will simply print the attribute values

  def __str__(self):
      return str(self.__collection_no) + ": " + self.__name + ", " + \
          str(self.__length) + " minutes, " + self.__format

• When we test it we get

  >>> from video import Video
  >>> v1 = Video("Forbidden Planet", 100, "DVD")
  >>> print(v1)
  4: Forbidden Planet, 100 minutes, DVD
  >>> str(v1)
  4: Forbidden Planet, 100 minutes, DVD

• You can see the code for the class here

Creating Superclasses

• In practice, you almost never create an object of the superclass
• It just has attributes and methods that subclasses will use
• The superclass contains methods and attributes shared by all subclasses
• Each subclass adds its own methods and attributes

Attendance

Class Exercise

Class Quiz