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

Questions

Are there any questions before I begin?

Graded Quiz

There is no quiz today but there will be one next Tuesday

Solution to Homework 8

I have posted a solution to homework 8 here.

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

Class Exercise

Class Quiz