IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 20

Review

Data Hiding
The __str__ Method
Accessor and Mutator Methods
Data Validation in The Constructor
Hiding Methods

New Material

A Practical Example of A Class
Other Methods for the Student Class
Creating Student Objects
Storing Objects for Future Use
Pickling in student_load.py
The Section Class
Adding Students to A Section Object
Import Statements and Global Variables
Being a Good Citizen

Homework 9

I have posted homework 9 here.

It is due this coming Sunday at 11:59 PM.

Quiz 7

Let's look at the answers to Quiz 7

Review

Data Hiding

Client code can change the attributes of a class directly
Unless you do something to prevent this
This might seem harmless but it can lead to trouble

The latest version of the Time class has one attribute

>>> from time_2 import Time
>>> t1 = Time("14:35:12")
>>> t1.seconds
52512
t1.format_time()
'2:35:12 PM'

If a user wanted to change that value
They would have to change a time like 9:45 into seconds
It would be quite a lot of work to perform this calculataion
And it would be easy to make a mistake

Worse than that, they might enter a totally ridiculous value

>>> t1.seconds  = 1000000000
>>> t1.format_time()
'277765:46:40 PM'

To prevent this we need to make the attributes invisible
Outside the class definition
This is called data hiding
To do this in Python we change the name of attributes
So they start with two underscore characters, __

The str Method

Classes can have certain methods whose names begin and end with __
These methods are sometime called magic methods
They are special because they are never called directly
__init__ is an example of a magic method
The client code calls __init__ using the name of the Class
```
ti = = Time("09:45:00")
```
__str__ is another magic method
It is called whenever you need a string representing an object
Like when you print it
```
print(t1)
```
If Time had no __str__ method and we tried to print it

Here is what we would get

>>> from time_3 import Time
>>> t = Time("09:30:00")
>>> print(t)
<time_3.Time object at 0x1013e8358>

The __str__ method must return a string

Like this

    def __str__(self):
        hours = self.seconds // (60 * 60)
        remainder = self.seconds % (60 * 60)
        minutes = remainder // 60
        seconds = remainder % 60
        return str(hours) + " hours " + str(minutes)+ " minutes " + str(seconds) + " seconds

You see the latest version of the Time class here

Accessor and Mutator Methods

A well designed class hides its attributes
But the client code sometimes needs to see those values
So you need to create special methods called accessors
Since it is common practice for the name of an accessor to begin with "get"
Another name for an accessor is a getter
Let's say you need to keep track of each computer in an office
You would need to record the following information about each machine
- Manufacturer
- Model
- Serial number
- Processor
- RAM
- Hostname
- Disk size

The first thing we need to do is create a constructor

def __init__(self, manufacturer, model, serial_number, processor, ram, hostname, disk_size):
    self.__manufacturer  = manufacturer
    self.__model         = model
    self.__serial_number = serial_number
    self.__processor     = processor
    self.__ram           = ram
    self.__hostname      = hostname
    self.__disk_size     = disk_size

All the attributes are hidden

So we need to create accessor for each

def get_manufacturer(self):
    return self.__manufacturer

def get_model(self):
    return self.__model

def get_serial_number(self):
    return self.__serial_number

def get_processor(self):
    return self.__processor

def get_ram(self):
    return self.__ram

def get_hostname(self):
    return self.__hostname

def get_disk_size(self):
    return self.__disk_size

The values of the following attributes should never change
- __manufacturer
- __model
- __serial_number
- __processor
That is one of the reasons we hide attributes
But some attributes could change with time
- __ram
- __hostname
- __disk_size
We need special methods to change these values
Such methods are called mutators
Since the common practice is to start a mutator name with "set"
Mutators are sometimes called setters

Here are the mutators for the Computer class

def set_ram(self, ram):
    self.__ram = ram

def set_hostname(self, hostname):
    self.__hostname = hostname

def set_disk_size(self, disk_size):
    self.__disk_size = disk_siz

Data Validation in The Constructor

The Time constructor needs to change its time_string parameter
To make sure it represents a valid time
Checking that values make sense before it is used is called data validation
First we need to make sure that time_string is is really a string
We can do this with the built-in function isinstance
The isinstance function takes two arguments
- An object
- The name of a class
It returns True if the object is an instance of the class
```
>>> isinstance("14:35:12", str)
True
```
If we don't get a string we should raise an exception

Like this

if not isinstance(time_string, str):
    raise TypeError("Time constructor expects a string argument")

Next we need to check whether the string has the right format

I am going to put this code in a method of its own called has_valid_format

# returns true if the string has the form HH:MM:SS
def has_valid_format(self,s):
    pattern = re.compile(r"\d\d:\d\d:\d\d")
    match = pattern.match(s)
    return match

Here we use regular expressions to try to match the string
If we have a match, match points to an object
And the calling statement will interpret this as True
If the string does not match, match will be None
Which is False in an if statement
Finally, we make sure that hours is between 0 and 23
And minutes and seconds are between 0 and 59

To do this I am going to create a new method date_numbers_in_range

# returns true if the numbers for hours, minutes and seconds
# are within the proper range
def date_numbers_in_range(self, hours, minutes, seconds):
    if not 0 <= hours <= 23:
        return False
    if not 0 <= minutes <= 59:
        return False
    if not 0 <= seconds <= 59:
        return False
    return True

Now we change the constructor to call these methods

# expects a string of the form HH:MM:SS
# where hours are expressed in numbers from 0 to 23    
def __init__(self, time_string):
    if not isinstance(time_string, str):
        raise TypeError("Time constructor expects a string argument")
    if not self.has_valid_format(time_string):
        raise ValueError("String must have the format HH:MM:SS")
    hours, minutes, seconds = tuple(time_string.split(":"))
    hours   = int(hours) 
    minutes = int(minutes)
    seconds = int(seconds)
    if not self.date_numbers_in_range(hours, minutes, seconds):
        raise ValueError("One of the time values is not in the proper range")
    self.__seconds = hours * 60 * 60 + minutes * 60 + seconds

Hiding Methods

The methods has_valid_format and date_numbers_in_range are only used by the constructor
They are not intended for use outside the class
So we should hide them by starting their names with __
Any method that is not needed outside the class should be hidden
A class should be a black box
With specified inputs and outputs
The client code has no need to know the internal workings of the class

New Material

A Practical Example of A Class

I use Python to help me administer my course work
Let's create a Student class that will help me do this
I need at least three values for each student
- Student ID
- Last Name
- First Name
This is all the information I have at the start of the semester
I will need other attributes for this class
- Preferred first name
- Phonetic spelling of the name
- Email address
- Unix username
But they will be added later
So the constructor sets them to the empty string

Here is the code for the constructor

def __init__(self, id, last_name, first_name):
    self.__id             = id
    self.__last_name      = last_name
    self.__first_name     = first_name
    self.__preferred_name = ""
    self.__phonetic_name  = ""
    self.__email          = ""
    self.__unix_username  = ""

I need accessors for each of these attributes

def get_id(self):
    return self.__id

def get_last_name(self):
    return self.__last_name

def get_first_name(self):
    return self.__first_name

def get_preferred_name(self):
        return self.__preferred_name

def get_phonetic_name(self):
    return self.__phonetic_name

def get_email(self):
    return self.__email

def get_unix_username(self):
    return self.__unix_username

Now I need mutators for the last four attributes

def set_preferred_name(self, preferred_name):
    self.__preferred_name = preferred_name

def set_phonetic_name(self, phonetic_name):
    self.__phonetic_name = phonetic_name

def set_email(self, email):
    self.__email = email

def set_unix_username(self, unix_username):
    self.__unix_username = unix_username

Other Methods for the Student Class

Now I need to create a __str__ method for this class

def __str__(self):
    return self.__first_name + " " + self.__last_name + ", " + self.__id

The first thing you should done after you create a method

Is to test it

>>> from student import Student
>>> student = Student("12345", "Smith", "William")
>>> print(student)
William Smith, 12345

I also need a method that returns the full name of the student
We'll call this method get_full_name
Normally this is the first name, a space and the last name
But I want to use the preferred first name
If the student has provided one

Here is the code

def get_full_name(self):
    if self.__preferred_name:
        return self.__preferred_name + " " + self.__last_name
    else:
        return self.__first_name + " " + self.__last_name

Which I test

>>> student.get_full_name()
'William Smith'
>>> student.set_preferred_name("Bill")
>>> student.get_full_name()
'Bill Smith'

Since I will be creating alphabetized lists I need a sort name
Which is the last name, a comma and a space, and the first name

Or the preferred name

def get_sort_name(self):
    if self.__preferred_name:
        return self.__last_name + ", "  + self.__preferred_name 
    else:
        return self.__last_name + ", "  + self.__first_name

Again I have to test

>>> student.get_sort_name()
'Smith, Bill'

You can see the code here

Creating Student Objects

When the semester starts I go to my register in WISER
And copy it into a text file
This file has the information I need
But not in the right format
So I will have to modify the file
To get the data in a format I can use
Each entry in this new file will have student data in the following format
```
STUDENT_ID,LAST_NAME,FIRST_NAME
```
Let's create another script, student_load.py
To read the file and create Student objects
The objects will be stored in a dictionary
Where the ID is the key
And the value is the Student object
This script is going to have three parts
- Setup
- Create the objects and store them
- Print student names
The last part is not strictly necessary
But it lets me know that the script is working properly
In the setup I will
- Import the Student class
- Create an empty dictionary
- Get the filename
- Create a file object

Here is the code

from student import Student

students = {}

data_filename = input("Data filename: ")
data_file     = open(data_filename, "r")

With the file object I can loop through the lines
To get the id, last name and first name
Using the string method split and multitple assignment
But first I need to remove the linefeed with rstrip
With these values in hand I can call the constructor
And store the object in the dictionary

Here is the code

for line in data_file:
    line = line.rstrip()
    id, last_name, first_name = line.split(",")
    student = Student(id, last_name, first_name)
    students[id] = student

The last section loops through the dictionary printing each entry
The loop variable is set to the student ID
Which I use to retrieve the object

And call its methods

for id in students:
    student = students[id]
    name = student.get_first_name() + " " + student.get_last_name()
    print(name)

You can see the code here

Storing Objects for Future Use

There is a major problem with this script
The dictionary disappears after the script ends
We need to store the dictionary for future use
All modern computer languages allow you to store objects
As a file on disk
These files can be read in later to restore the object
This process is called serializing
Python lets you serialize an object but it calls the process pickling
Pickling is a process for preserving food through fermentation
Examples are pickles, sauerkraut and kimchi
There is a module in the standard library named pickle
It contains functions to serialize objects
Here is how it works
First you must import the pickle module
```
import pickle
```
Next you have to open a file using a special access mode
I have told you to use the "w" access mode to write to a file
But that it for text files
Pickling uses binary files
Which need different acces modes
To open a file for writing binary data we use the "wb" access mode
```
pickle_file = open(PICKLE_FILENAME, "wb")
```
Then we use the dump function of the pickle module
To serialize the object
dump takes two arguments
- The object being serialized
- A binary file object
We call it like this
```
pickle.dump(students, pickle_file)
```
Loading an object from a data file is a similar process
First we open the file with the "rb" (read binary) access mode
```
pickle_file = open(PICKLE_FILENAME, "rb")
```
Then we reconstruct the object using load
It takes the file object as its only parameter
```
students = pickle.load(pickle_file)
```

Pickling in student_load.py

There is another problem with student_load.py
Students may register for the class after I have create the students dictionary
And have pickled it
When this happens I create another copy of the WISER roster
And another copy of the text file with id, last name and first name
If I run the script on the new version of the input file
Some students will be entered twice
So I need a more sophisticated algorithm
First I need to see if there is a pickle file
If there is, I need to load the students dictionary
If there isn't, I need to create an empty dictionary
Then I need to open the text file
And read in the data for each student
But I will only add it to the dictionary if it is a new student

Here is the pseudocode

try to open the pickle file
if the file exists
    create the students dictionary from the pickle file
else:
    create an empty dictionary
open the text file with student data
loop through the text file
    get the id, first name and last name
    if the id is not in the students dictionary:
        create a student object
        add the new object to the dictionary

Here is the code

PICKLE_FILENAME = "students.dat"
try:
    pickle_file = open(PICKLE_FILENAME, "rb")
except:
    students = {}
else:
    students = pickle.load(pickle_file)
    pickle_file.close()

data_filename = input("Data filename: ")    
try:
    data_file = open(data_filename, "r")
except:
    print("Cannot open", data_file)
    sys.exit()

for line in data_file:
    line = line.strip()
    id, last_name, first_name = line.split(",")
    if id not in students:
        student = Student(id, last_name, first_name)
        students[id] = student
data_file.close()

The Section Class

I can teach the same class at different times
Each different meeting time is a section
I have a script that I use to take attendance
This script needs an alphabetical list of all students in the section
To get this list I will create a Section class
The class will have four attributes
- A unique ID to identify the course
- The semester
- The section number
- IDs of registered students
For a course ID I use "it" followed by the course number
So this course has a course ID of "it117"
Each year has three semesters
- Fall - abbreviated "f"
- Spring - abbreviated "s"
- Summer - abbreviated "sum"
The semester value uses these abbreviations
Followed by a two digit year
So the Fall 2020 semester will be recorded as "f20"

Here is the constructor

def __init__(self, course_id, semester, section_no):
    self.__course_id   = course_id
    self.__semester    = semester
    self.__section_no  = section_no
    self.__student_ids = set()

Notice that the __student_ids is assigned the empty set
It is a set since there should be no duplicate student IDs

Adding Students to A Section Object

I will use a Section object to create lists of students in that section
The constructor will need to populate __student_ids
Which it will do by reading in a file with the format
```
STUDENT_ID,LAST_NAME,FIRST_NAME
```
I need a method to read in this file
And store ID in __student_ids
When we wrote student_load.py we changed the code
So it would not create duplicates
It is impossible to store duplicate entries in a set
So we don't have to write code to check for this
This is why the attribute is a set, not a list

Here is the code

    # reads a text file that has the format
    #        STUDENT_ID,LAST_NAME,FIRST_NAME
    # adds these students to __student_ids
    def add_students(self, data_filename):
        try:
            data_file = open(data_filename, "r") 
        except:
            print("Could not open", data_file)
            sys.exit()
        for line in data_file:
            line = line.strip()
            id, last_name, first_name = line.split(",")
            self.__student_ids.add(id)
        data_file.close()

get_enrolled_students returns a dictionary of student objects

For all students enrolled in the section

    # retrieves the pickled students dictionary
    # and uses it to create a new dictionary
    # of student object for students enrolled in this section
    def get_enrolled_students(self):
        enrolled_students = {}
        try:
            pickle_file = open(PICKLE_FILENAME, "rb")
        except:
            print("Could not open", PICKLE_FILENAME)
            sys.exit()
        students = pickle.load(pickle_file)
        pickle_file.close()
        for id in self.__student_ids:
            enrolled_students[id] = students[id]
        return enrolled_students

When I run this with the following test code

from section import Section

section = Section("it117", "s17", 1)
print(section)
section.add_students("students.txt")
enrolled_students = section.get_enrolled_students()
for id in enrolled_students:
    print(enrolled_students[id])

I get

it117 s17 section 1
 Smith  John, 34524
 Adams  Jane, 45235

You will find the code for this class here

Import Statements and Global Variables

add_students uses code imported from two modules
- student
- pickle
Where to these import statements belong?
Import statements make module code available to the entire class
That means they need to appear at the top of the file
Before the class definition
If the class uses global variables

They also need to be declared at the top of the file

from student import Student
import pickle

PICKLE_FILENAME = "students.dat"

class Section:
...

Being a Good Citizen