IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 28 - Final Review

Review

Objects and Classes
Classes Are Used by Other Programs
Defining a Class
The Constructor Is Special
Creating An Object from A Class
The self Variable
Data Hiding
The __str__ Method
Accessor and Mutator Methods
Import Statements and Global Variables
Type Conversion Magic Methods
Recursive Functions
Writing Recursive Functions
Calculating the Factorial of a Number
Calculating Fibonacci Numbers
Directory Walk
Replacing Recursion with a Loop
Direct versus Indirect Recursion

Microphone

Questions

Are there any questions before I begin?

Final Exam

The final exam will be held on Thursday, May 21st from 3 to 6 PM.

The exam will be given in this room.

If for some reason you are not able to take the Final at the time it will be offered, you MUST send an email to me before the exam so we can make alternative arrangements.

The final will consist of questions taken from the Weekly Graded Quizzes, along with questions asking you to write short segments of Python code.

There is a link to the answers to the graded quizzes on the class web page.

60% of the points on this exam will consist of questions from the Graded Quizzes.

You do not need to study a Graded Quiz question if the topic is not mentioned in either the Midterm or Final review.

The remaining 40% will come from 4 questions that ask you to write some code.

To study for the code questions you should know

How to write a regular expression
How to use the os and sys modules
How to write a class definition
How to write a recursive function

A good way to study for the code questions is to review the Class Exercises, homework solutions and Class Notes.

The today's class will be a review session.

You will only be responsible for the material in this review session, and the review for the Midterm, which you will find here.

Although the time alloted for the exam is 3 hours, I would expect that most of you would not need that much time.

The final is a closed book exam.

To prevent cheating, certain rules will be enforced during the exam.

Course Evaluation

At the end of each semester we offer you the opportunity to say what you think about this course.

What have I done right?

What have I done wrong?

What can I do better?

You are not asked for you name.

So the submissions are anonymous.

I will not see your responses until after I have submitted grades for this course.

We collect this feedback through Course Evaluations.

I will use what you say to make this course better.

To complete the course evaluation, use the following link .

After I finish speaking I will leave the class but stand outside the door.

I will ask all of you to fill out the Course Evaluation

No Class Next Week

A normal semester has 28 classes.

But this semester has 29.

I do not have materials for a 29th class.

Next Tuesday I will have Zoom Office Hours, from 9 AM to 5 PM, instead of a class.

The Zoom session will be conducted from my home in Somerville.

Not my office on the UMB campus.

Attendance

Today's Class

Today I will review the material that we have covered since the midterm that you will have to know for the final.

Review

Objects and Classes

Objects are chunks of RAM that can hold one or more values
These values are called attributes
Objects contain functions that work on the attributes called methods
Objects do not have names
Instead they have a location in RAM
When you create an object you store this location in an object variable
You then use dot notation on this object to call its methods
A class defines an object
The class serves as a template from which objects are created
An object created from a class is an instance of that class
Some classes, like strings, are built into the Python interpreter
But you can create your own classes by defining classes for them

Classes Are Used by Other Programs

Classes are usually contained in modules
In other words, in separate files
To use a class defined in a module you must import it
The script that uses a class is often called the client code

Defining a Class

The general format for a class is

class CLASS_NAME:
    def __init__(self[, PARAMETER, ...]):
        ...

    def METHOD_NAME(self[, PARAMETER, ...]):
        ...

By convention, all class names in Python are Capitalized
A class definition consists of a number of method declarations
One of which is the constructor ...
which must be named __init__
This method is used to create the objects of the class
The attributes (values) of a class are defined within its methods ...
usually in the constructor
The class definition is the template used to create the object
The object is the thing that lives in memory

The Constructor Is Special

A constructor is a special method that creates an object ...
and returns a pointer to the object ...
which is stored in an object variable
In Python, the constuctor must be named __init__
It has no return statement
Every class should have a constructor

Creating An Object from A Class

__init__ cannot be called directly
Instead you use the name of the class

The general format is

OBJECT_VARIABLE = CLASS_NAME([PARAMETER, ...])

In a previous class, we created an object like this
```
date = Date(date_string)
```
The variable date points to the Date object ...
which was created by the call to the constructor
We can then use dot notation on the object variable ...
to access the object's methods
Like this
```
print(date.format_date())
```

The self Variable

Every method defined in a class has self as a parameter
We only use self inside the class ...
when we need to call a method ...
or refer to the attributes (values) of the class
We cannot use self outside the class
self represents the individual object created by the constructor

Data Hiding

By default the client program can change the attributes of an object directly

Like this

>>> from time_1 import Time
>>> t1 = Time("14:35:12")
>>> t1.seconds
12
>>> t1.seconds = 5000000000
>>> t1.seconds
5000000000

This is a bad idea
Because the attribute might need to be restricted ...
to a certain range of values
To prevent this we need to make the attributes invisible outside the class
This is called data hiding
To do this in Python we change the name of attributes ...
so they start with two underscore characters, __
You can also hide methods the same way

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
```
t1  = Time("09:45:00")
```
__str__ is another magic method
It is called whenever you need a string representing the 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

    # returns a string formated as follows
    # H[H] hours M[M] minutes S[S] seconds
    def __str__(seconds):
        hours = seconds // (60 * 60)
        remainder = seconds % (60 * 60)
        minutes = remainder // 60
        seconds = remainder % 60
        return str(hours) + " hours " + str(minutes)+ " minutes " + str(seconds) + " seconds

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 ...
to see the values of these attributes
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_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

Import Statements and Global Variables

Sometimes a class defined in a module needs to import other modules
These import statements need to be at the top of the file ...

outside the class definition

from student import Student
import pickle

class Section:
...

Global variables also need to be declared at the top of the file
Again they must be outside the class definition

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)

How we implement each of the these magic methods is up to us

Recursive Functions

The body of a function consists of statements
A function call is a statement
So a function can call another function
It can even call itself
A function that calls itself is a recursive function

Writing Recursive Functions

The trick in writing recursive functions ...
is to make sure the code will not go on forever
Something in the code must make it stop eventually
Two conditions are required to make this happen
There must be some condition where recursion stops
This is called the base case
And the argument in the recursive call ...
where a function calls itself ...
must get closer to the base case

Here is a recursive function that counts down from some number

def count_down(num):
    print(num)
    if num > 1:
        count_down(num - 1)

The function will only call itself ...
if num is greater than 1
And each time the function calls itself ...
num decreases by 1
This prevents the function from running forever
Here is what we get when we call the function
With an argument of 10
```
10
9
8
7
6
5
4
3
2
1
```

Calculating the Factorial of a Number

To make sure that recursion comes to an end ...
you must have two things
- Code that that makes the recursion stop
- Code that works toward this end condition
The condition that causes the program to end is called the base case
The factorial of n is written as
```
n!
```
It is defined as product of multiplying all number from 1 ...
up to n
The formula for factorial is
```
n! = (n-1)! * n
```
The factorial of 1 has a different value
```
1! = 1
```
This is the base case

Here is a recursive function to calculate the factorial

def factorial(num):
    if num == 1:
        return 1
    else:
        return factorial(num -1) * num

Calling this function I get
```
>>> print("5!:",factorial(5))
5!: 120
```

Calculating Fibonacci Numbers

The Fibonacci numbers are a sequence of integers
The first two numbers are
```
1 1
```
The next number is the sum of the preceding two numbers
Here are the first ten Fibonacci numbers
```
1 1 2 3 5 8 13 21 34 55
```
Here's the formula for the nth Fiboacci number in the sequence
```
F(n) = F(n - 1) + F(n - 2)
```
But this definition only works if we further specify
```
F(1) = 1
F(2) = 1
```
They are the base cases

Here is a recursive function to calculate the nth Fibonacci number

def fibonacci(num):
    if num == 1 or num == 2:
        return 1
    else:
        return fibonacci(num - 1) + fibonacci(num - 2)

Directory Walk

To do things like count the number of directories ...
starting from a certain point in the file system ...
we have to perform a directory walk

Here is the algorithm

set count to 0
get a list of all the entries in the current directory
for each entry
   if the entry is a directory
      increase count by 1
      run the function on this directory and increase count by what it returns
return the count

Here is the code

def dir_count(path):
   count = 0
   entries = os.listdir(path)
   for entry in entries:
      entry_path = path + "/" + entry
      if os.path.isdir(entry_path):
         count += 1
         count += dir_count(entry_path)
   return count

Replacing Recursion with a Loop

Anything that can be done with recursion ...
can also be done with a loop
Recursive functions take more memory than loops
Each time you make a recursive call ...
the interpreter sets aside a bit of memory for that call ...
which is only released when the function ends
So why use recursion at all?
Because it can save time when writing code
It is often easier to create a recursive algorithm ...
than one that uses a loop
Memory is relatively cheap
And good programmers are expensive
So it's often best to go with recursion

Direct versus Indirect Recursion

Recursion is where a function calls itself
The functions above call themselves directly
This is called direct recursion
But you can also have indirect recursion
In indirect recursion a function calls another function ...
and that other function calls the original function
So if function A called function B ...
and function B called function A ...
that would be an example of indirect recursion
There can be any number of functions involved in indirect recursion
So function A can call function B
Which calls function C
Which calls function D
Which calls function A

Review

Questions

Final Exam

Course Evaluation

No Class Next Week

Attendance

Today's Class

Review

Objects and Classes

Classes Are Used by Other Programs

Defining a Class

The Constructor Is Special

Creating An Object from A Class

The self Variable

Data Hiding

The __str__ Method

Accessor and Mutator Methods

Import Statements and Global Variables

Type Conversion Magic Methods

Recursive Functions

Writing Recursive Functions

Calculating the Factorial of a Number

Calculating Fibonacci Numbers

Directory Walk

Replacing Recursion with a Loop

Direct versus Indirect Recursion

The str Method