IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 22

Microphone

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.

Questions

Are there any questions before I begin?

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
Which means writing a hashbang line as the first line in the script
On pe15.cs.umb.edu the hashbang line should be
```
#! /usr/bin/python3
```
You also need to give the file read and execute permission
You can do this in FileZilla by right clicking on the file ...
scrolling down to the Permissions box ...
and entering 755
You can also do this on the Unix command line
```
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
But only if we define methods with the specific magic method name

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

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 module with 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 ...

if we 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
>>> 
```

Attendance

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
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 a particular 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 all living things is called taxonomy
It 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(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(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(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")
>>>

Static Methods

If you look carefully at the headers of the validations methods ...
you will see something odd
None of them take self as a parameter
There is no need for them to use self
They only work with the value in their single paramater
They do not access any attributes of the class
They are actually called before the attribute are assigned any value
Methods like this are called static methods
They belong to the class itself
Not to a specific instance of a class

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 text 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():
    try:
        file = open(FILENAME, 'r')
        collection_no = int(file.readline())
    except FileNotFoundError:
        collection_no = 1
    else: 
        collection_no += 1
        file.close()
    finally:
        file = open(FILENAME, 'w')
        file.write(str(collection_no))
        file.close()
        return collection_no

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

Honesty and Trust