IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 21

Microphone

Questions

Are there any questions before I begin?

Solution to Homework 8

I have posted a solution to homework 8 here.

Homework 10

Homework 10 is posted here.

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

Graded Quiz Today

After I finish talking I will pass out the papers for today's graded quiz.

Today's Class

Today I will talk more about exceptions and the try/catch statement.

Course Requirements

Last Change to Homework Script Rules

The last additon the the Rules for Homework Scripts involves exceptions
Whenever you write a statement that could cause a run time excpetion ...
you must place it inside a try except statement

Tips and Examples

Don't Use `with` Statements

Whenever you use open to create a file object ...
you run the risk of a run time error
To deal with this problem, put the call to open inside the try block ...
of a try/except statement
If you do an Internet search on creating file objects in Python ...
you may come across the with statement
This is an advanced feature of Python for experienced programmers
Do not use the with statement in any assignment for this course
If you do you will lose points
Because you need experience dealing with run time errors

Review

Errors

It is easy to get an error when writing scripts
But to fix errors it is important to recognize the different error types
There are three classes of errors
- Syntax errors
- Logic errors
- Runtime errors

Syntax Errors

Syntax errors occur when a statement violates a rule of the Python language

>>> for = 5
  File "<stdin>", line 1
    for = 5
        ^
SyntaxError: invalid syntax

Python does not let you use a keyword as a variable name

A common type of syntax error is when you misspell the name of a function or variable

>>> name = "Glenn"
>>> print(nme)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'nme' is not defined

Another common syntax error is leaving out a )

$ cat get_number_1.py 
#! /usr/bin/python3

number = int(input("Number: ")

$ ./get_number_1.py 
  File "./get_number_1.py", line 6

                                  ^
SyntaxError: unexpected EOF while parsing

Indentation problems are also syntax errors

>>> for i in range(5):
...     num = i * 2
...   print(num)
  File "<stdin>", line 3
    print(num)
             ^
IndentationError: unindent does not match any outer indentation level

Syntax errors are the most common errors encountered when writing scripts
But they are the easiest to fix

Logic Errors

A logic error occurs when the code does not give the correct results

Here is an example

average = num_1 + num_2 / 2
print ('Average:', average)

The numerator should be sum of both num_1 and num_2
But here it is only num_2
We need to change the code to
```
average = (num_1 + num_2) / 2
```
You get no error message with a logic error
You will not know you have an error unless you test your code
This is why it is always important run tests on the scripts you write

Runtime Errors

Runtime errors occur only when the the program is run
They happen when a bad value makes a statement fail
If the program is run again with a different value ...
no runtime error would occur

A common runtime error is to open a file that does not exist

$ ./file_open.py 
Filename: xxxxxx
Traceback (most recent call last):
  File "./file_open.py", line 6, in <module>
    file     = open(filename, "r")
FileNotFoundError: [Errno 2] No such file or directory: 'xxxxxx'

If you try to open a file for which you have no permission ...

you will get another type of runtime error

$ ./file_open.py 
Filename: unreadable.txt
Traceback (most recent call last):
  File "./file_open.py", line 6, in <module>
    file     = open(filename, "r")
PermissionError: [Errno 13] Permission denied: 'unreadable.txt'

Giving a conversion function a value it can't handle ...

is another runtime error

$ ./int_request.py 
Integer: five
Traceback (most recent call last):
  File "./int_request.py", line 5, in <module>
    number = int(input("Integer: "))
ValueError: invalid literal for int() with base 10: 'five'

Or you can give a function an argument with the wrong type

>>> round("five")
Traceback (most recent call last):
  File "<stdin>, line 1, in <module>
TypeError: type str doesn't define __round__ method

Or divide by zero

$ ./divide_two_numbers.py 
Numerator: 5
Denominator: 0
Traceback (most recent call last):
  File "./divide_two_numbers.py", line 7, in <module>
    result      = numerator / denominator
ZeroDivisionError: division by zero

Exception Objects

Python has a mechanism that deals with runtime errors
It gathers information about what happened and where ...
and uses it to create an error message
It does this by creating an exception object
When this happens we say that the interpreter has raised an exception

Catching Exceptions

The exception mechanism is more that just a way to create error messages
Python allows you to catch exception objects in your code ...
while your script is running
Your code can then do something to prevent the script from aborting
You do this with a try/except statement

Which has the following form

try:
    STATEMENT
    STATEMENT
    ...
except:
    STATEMENT
    STATEMENT
    ...

The statements in the try code block execute normally ...
unless a runtime error occurs
If a runtime error occurs, it stops executing the statements in the try block
Instead, it jumps to the except code block ...
and executes those statements
When your code does this, it is said to catch an exception
A call to open should always be put inside a try/except statement

Like this

$ cat open_file.py
#! /usr/bin/python3

# demonstrates using a try/except statement 
# to catch exceptions encountered while
# trying to open a file

filename = input("Filename: ")
try:
    file = open(filename, "r")
    for line in file:
        print(line.strip())
except:
    print("Could not open file", filename)

$ ./open_file.py
Filename: xxxx
Could not open file xxxx

Notice that the interpreter never ran the for loop

Exceptions and Data Validation

Whenever we get data from the user we need to check it ...
to see if it is something the code can handle
This is called data validation
We can use input to ask the user for a number
But input returns a string ...
so we need to use a conversion function
However, both int and float can cause a runtime error ...
if given a string that can't be converted into a number ...
like "foo"
So we need to call them inside a try/except statement too
We should put this inside a while loop
That way the it will keep running ...
until we get valid input

Here is a function that does that

def get_integer():
   while True:
      number = input("Integer: ")
      try:
         number = int(number)
         return number
      except:
         print(number, "cannot be converted into an integer")

Attendance

New Material

The Code in the `try` Clause

In some of my scripts I call open with a string literal for the filename
```
file = open("temps.txt", "r")
```
A more realistic script would ask the user for this information

But if the user enters the wrong filename you will get a runtime error

$ ./temps_average_2.py 
Filename: xxx
Traceback (most recent call last):
  File "./temps_average_2.py", line 7, in <module>
    file = open(filename, 'r')
FileNotFoundError: [Errno 2] No such file or directory: 'xxx'

To fix this, I should put the call to open in the try block

filename = input("Filename: ")
try:
    file = open(filename, "r")
except:
    print("Cannot open", filename)

count = 0
total = 0
for line in file:
    count += 1
    date, temp = line.split()
    temp   = int(temp)
    total += temp
    
average = round(total/count, 2)
print("Average:", average)

This fixes one problem but creates another

$ ./temps_average_3.py 
Filename: xxx
Cannot open xxx

Traceback (most recent call last):
  File "./temps_average_3.py", line 15, in <module>
    for line in file:
NameError: name 'file' is not defined

The open statement must work ...
for the rest of the script to work
So if the open statement causes a run time error ...
the rest of the script code should not run
There is more than one way to fix this
We can put every statement that needs the file object ...

inside the try block

filename = input("Filename: ")
try:
    file = open(filename, "r")
    count = 0
    total = 0
    for line in file:
        count += 1
        date, temp = line.split()
        temp   = int(temp)
        total += temp

    average = round(total/count, 2)
    print("Average:", average)
except:
    print("Cannot open", filename)

This version better handles a bad filename

$ ./temps_average_4.py
Filename: xxx
Cannot open xxx

Different Exception Types

When a runtime error occurs Python creates an exception object
When this happens the interpreter is said to raise an exception
The exception mechanism has three purposes
- To allow the interpreter to handle the runtime error
- To give the programmer some idea of what went wrong
- To give the programmer the chance to do something about it
There is more than one way to cause a runtime error
So different exception objects are created for different types of exceptions

Common Exception Types

Let's look at some of the more common types of exception objects
When you try to open a file that does not exists ...

the interpreter creates FileNotFoundError exception object

>>> open("xxx.txt","r")

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'xxx.txt'

This tells the user that they entered the wrong filename
If you try to open a file for which you do not have permission ...

a PermissionError object will be created

file = open("test.txt","r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
PermissionError: [Errno 13] Permission denied: 'test.txt'

It is not enough to have the correct filename
If you don't have read permission on the file ...
you won't be able to open it
If a conversion function gets an argument of the wrong data type ...

a TypeError object is created

>>> round("foo")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: type str doesn't define __round__ method

The round function only works with numbers
If you give a function a value it can't handle ...

a ValueError object is created

>>> int("567")
567
>>> int("5x7")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '5x7'

The int function only works when all the characters are digits
If you try to divide by zero ...

the interpreter will create a ZeroDivisionError exception object

>>> print(5/0)
Traceback (most recent call last):
  File "", line 1, in 
ZeroDivisionError: division by zero

Dividing by zero has no meaning in mathematics or Python
There is more than one way to deal with these issues
One way is to put all the code that creates the exception ...
inside the try block

Handling More Than One Type of Exception

Here is a function which asks for a filename ...

and returns a file object

def open_file_read():
   while True:
      filename = input("Filename: ")
      try:
         file = open(filename, "r")
         return file
      except:
         print("Cannot open", filename)

This function keeps looping until I give it a good filename

$ ./file_open_2.py
Filename: xxx
Cannot open xxx
Filename:

But there are two runtime errors that this function could encounter
- File not found
- Permission error
It would be nice if the function could tell the difference
It could then give a more specific error message
I have shown you the simplest version of the try/except statement
```
try:
    STATEMENT
    ...
except:
    STATEMENT
    ...
```
But there is another form
There can be different except clauses for each type of exception object

The format is

try:
    STATEMENT
    ...
except EXCEPTION_TYPE_1:
    STATEMENT
    ...
except EXCEPTION_TYPE_2:
    STATEMENT
    ...
...

You can catch as many exception types as you want
But you must spell the name of the exception correctly ...
or you will get a syntax error

We can use this format to write an improved version of the function

def open_file_read():
    while True:
        filename = input("Filename: ")
        try:
            file = open(filename, "r")
            return file
        except FileNotFoundError:
            print("Cannot find", filename)
        except PermissionError:
            print("You do not have permission to read", filename)

Now we get different error messages for different exceptions

$ ./file_open_3.py 
Filename: xxx
Cannot find xxx
Filename: unreadable.txt
You do not have permission to read unreadable.txt
Filename:

Using the Data in Exception Objects

Look at the first error message above
```
Cannot find xxx
```
This error message was written inside the function
But if we had not caught the exception ...

we would have seen the following

>>> open("xxx", "r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'xxx'

The text of this error message is contained in the exception object
We can get this error message with a slightly different form of the except header
In this variant we create a variable that points to the exception object
```
except EXCEPTION_TYPE as VARIABLE:
```
A commonly used variable name for the exception is err
But this is only a convention
You can use any valid variable name to reference the exception object
With this variable you can access anything inside the object
If you print the variable it will give you the error message

Here is a new version of the function that uses this feature

def open_file_read():
    while True:
        filename = input("Filename: ")
        try:
            file = open(filename, "r")
            return file
        except FileNotFoundError as err:
            print(err)
        except PermissionError as err:
            print(err)

Here is what happens when we use it

$ ./file_open_4.py
Filename: xxx
[Errno 2] No such file or directory: 'xxx'
Filename: unreadable.txt
[Errno 13] Permission denied: 'unreadable.txt'
Filename:

The text in blue is user input

The statements inside an except block are called an exception handler

The `else` Clause

A try/except statement can also have an else clause
All the statements in the try block are executed ...
unless one of them causes a runtime error
The code in an else clause runs if there is no runtime error
Earlier I showed you code ...

that will cause an error if the open command fails

filename = input("Filename: ")
try:
    file = open(filename, "r")
except:
    print("Cannot open", filename)

count = 0
total = 0
for line in file:
    count += 1
    date, temp = line.split()
    temp   = int(temp)
    total += temp
    
average = round(total/count, 2)
print("Average:", average)

If no file object is created, the for loop cannot work ...
and you will get a runtime error
I showed you one way to fix this ...
by moving the code in red to the try code block

Like this

try:
    file = open(filename, "r")
    count = 0
    total = 0
    for line in file:
        count += 1
        date, temp = line.split()
        temp   = int(temp)
        total += temp

    average = round(total/count, 2)
    print("Average:", average)
except:
    print("Cannot open", filename)

But there is a better way

You could put the code in an else clause

try:
    file = open(filename, "r")
except:
    print("Cannot open", filename)
else:
    count = 0
    total = 0
    for line in file:
        count += 1
        date, temp = line.split()
        temp   = int(temp)
        total += temp

    average = round(total/count, 2)
    print("Average:", average)

Why is it better?
I think the try code block ...
should only contain code that could cause a runtime error
We could put other code here ...
but that is not really the purpose of the try clause
This new form of the code is easier to read
Reading from the top, we first encounter a short try clause
Then a short except clause
With this out of the way we can get to the meat of the script ...
in the else clause

The `finally` Clause

There is another type of clause that can occur a try/except statement
It has the format
```
finally:
    STATEMENT
    ....
```
The statements in a finally clause will always be executed
It does not matter whether a run time error occurs
I used this clause in script for my IT 117 class
I needed to create series of numbers that started with 1 ...
and constantly increased
The last number created would be stored in a file on disk
If there is no file, this is the first run of the function ...
so the number returned should be 1
If the is a file that old number should be read ...
and increased by 1
Whatever the case the number should be written to the file ...
and returned

The function below should uses all possible try/except clauses

# 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
    finally:
        file = open(FILENAME, 'w')
        file.write(str(collection_no))
        return collection_no

Throwing Exceptions in Code

Exceptions classes were created to allow the Python interpreter ...
to handle run time errors
But you can write code that also throws exceptions
Why would you want to do this?
There can be very useful programs that have a lot of parts
Exceptions are a good way for those parts to talk to each other
Let me give you an example
Some objects are built into the Python interpreter
But Python allows you to create you own objects by defining a class
A class is a template or blueprint for a new object
It defines the variables and methods for the object
The programs that use this new class to create new objects ...
are called client code
Because this code uses the services provided by the class
When the class encounters a problem it needs to communicate that ...
to the client code
It does that by raising an exception
All classes have secial programs called constructors ...
that create the object
The constructors are given values that need to be stored in the object
If the constructor has been given a value it cannot use ...
it should raise an exception
Why?
Because it is not the job of the class to deal with this problem
That is the job of the client code
Here is code that raises an exception when the value given for variable time_string ...

is not a string

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

The class has done its job
It has notified the client code of the problem
It is the responsibility of the client code to catch the exception ...
and deal with it

Do No Harm