IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 21

Microphone

Graded Quiz

You can connect to Gradescope to take weekly graded quiz today during the last 15 minutes of the class.

Once you start the quiz you have 15 minutes to finish it.

You can only take this quiz today.

There is not makeup for the weekly quiz because Gradescope does not permit it.

Solution to Homework 8

I have posted a solution to homework 8 here.

Let's take a look.

Homework 10

Homework 10 is posted here.

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

Questions

Are there any questions before I begin?

Tips and Examples

Don't Create a File Object When Given One as a Parameter

In homework 8 you were asked to create three functions
- random_integers_write
- average_from_file
- divide_by_three_count
Each one of these functions received a file object as a parameter ...
which you can see by looking at the function headers
- def random_integers_write(file, min, max, entries):
- def average_from_file(file):
- def divide_by_three_count(file):
Yet many student created a file object inside the function ...
and lost 10 point each time they did
There is no excuse for this kind of error
It happens when someone works to quickly ...
without taking the time to think
Good code can automate boring tasks
But writing the code requires you to think ...
about what must be done
If you skimp on thinking ...
your code will not work

Don't Use Code You Copied from Google

I sometimes see students using code that they must have copied from Google
I can tell, because they use a Python construction I have not taught
All problems in this course can be solved using what I have taught you
To write code for this course ...
you only need to read the Class Notes
I know that many of you have too many commitments ...
and have little time to work on your assignments ...
so you search on Google for the answer
But Googling is not learning
Learning takes effort ...
but it results in understanding ...
which allows you to do more
You should never use Python features you do not understand
Programming in Python requires understanding what you are trying to do ...
and the language features you need to make it happen

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 it 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.rstrip())
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
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 import a module that doesn't exist ...

an ImportError object is created

>>> import foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named 'foo'

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 last error message above

You do not have permission to read unreadable.txt

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
We will not have to use this feature of Python
But in more advanced scripts it can be useful
The finally clause allows you to clean up any loose ends
No matter what happens when the script is run

Do No Harm