IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 21

Review

Errors
Syntax Errors
Logic Errors
Runtime Errors
Exception Objects
Catching Exceptions
Exceptions and Data Validation

New Material

The Code in the try Clause
Different Exception Types
Common Exception Types
Handling More Than One Type of Exception
Using the Data in Exception Objects
The else Clause
The finally Clause
Do No Harm
Throwing Exceptions in Code

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.

Write your name clearly at the top.

When you finish the Quiz hand it to me.

Then you can work on the Class Exercise and today's ungraded quiz.

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

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 specific 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
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 ...

a FileNotFoundError exception object is created

>>> 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'

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'

If a conversion function gets the wrong type of argument ...

a ValueError object is created

>>> number = float(input("Number: "))
Number: five
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'five'
>>> number = float(input("Number: "))
Number: 5..4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: '5..4'

If you try to divide a number by zero ...

the interpreter will create a ZeroDivisionError exception object

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

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

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 error message is contained in the exception object
We can get the 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

The following code 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
You could fix this by putting everything in 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?
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 runtime error occurs
I used this clause in script for my IT 117 class
I needed to create series of numbers that started with ...
and constantly increased
The last number created will 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?
They can be very useful programs that have a lot of parts
Because exceptions are a goog way for those parts to talk to each other
Let mr 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 the class to create new objects ...
are called client code
Because the use 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
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

Review

New Material

Questions

Solution to Homework 8

Homework 10

Graded Quiz Today

Review

Errors

Syntax Errors

Logic Errors

Runtime Errors

Exception Objects

Catching Exceptions

Exceptions and Data Validation

Attendance

New Material

The Code in the try Clause

Different Exception Types

Common Exception Types

Handling More Than One Type of Exception

Using the Data in Exception Objects

The else Clause

The finally Clause

Throwing Exceptions in Code

Class Exercise

Class Quiz

The Code in the `try` Clause

The `else` Clause

The `finally` Clause