Creating an error is referred to as raising an exception. You saw some examples of exceptions in the previous section. You can also define your own exceptions, of a predefined type or type-less. Raising an exception is done with the command like this:

raise Exception("Something went wrong")

It might be tempting to print out error messages when something goes wrong, for example, like this:

print("The algorithm did not converge.")

This is not recommended for a number of reasons. Firstly, printouts are easy to miss, especially if the message is buried in many other messages being printed to your console. Secondly, and more importantly, it renders your code unusable by other code. The calling code will have no way of knowing that an error occurred and therefore have no way of taking care of it.

For these reasons, it is always better to raise an exception instead. Exceptions should always contain a descriptive message, for example:

raise Exception("The algorithm did not converge.")

This message will stand out clearly for the user. It also gives the opportunity for the calling code to know that an error occurred, and to possibly find a remedy.

Here is a typical example of checking the input inside a function to make sure it is usable before continuing. For an example, a simple check for negative values and the correct data type ensures the intended input of a function to compute factorials:

def factorial(n):
  if not (n >=0 and isinstance(n,(int,int32,int64))):
    raise ValueError("A positive integer is expected")
    ...

The user of the function will immediately know what the error is, if an incorrect input is given, and it is the user's responsibility to handle the exception. Note the use of the exception name when raising a predefined exception type, in this case ValueError followed by the message. By specifying the type of the exception, the calling code can decide to handle errors differently depending on what type of error is raised.

Summing up, it is always better to raise exceptions than to print error messages.

Dealing with an exception is referred to as catching an exception. Checking for exceptions is done with the try and except commands.

An exception stops the program execution flow and looks for the closest try enclosing block. If the exception is not caught, the program unit is left and it continues searching for the next enclosing try block in a program unit higher up in the calling stack. If no block is found and the exception is not handled, execution stops entirely; the standard traceback information is displayed.

Let's look at an example for the try statement:

try:
    <some code that might raise an exception>
except ValueError:
    print("Oops, a ValueError occurred")

In this case, if the code inside the try block raises an error of type ValueError, the exception will be caught and the message in the except block printed. If no exception occurs inside the try block, the except block is skipped entirely and execution continues.

The except statement can catch multiple exceptions. This is done by simply grouping them in a tuple, like this:

except (RuntimeError, ValueError, IOError):

The try block can also have multiple except statements. This makes it possible to handle exceptions differently depending on the type. Let's see an example of multiple exception types:

try:
    f = open('data.txt', 'r')
    data = f.readline()
    value = float(data)
except OSError as oe:
    print("{}:  {}".format(oe.strerror, oe.filename))
except ValueError:
    print("Could not convert data to float.")

Here an OSError will be caught if, for example, the file does not exist; and a ValueError will be caught if, for example, the data in the first line of the file is not compatible with the float data type.

In this example we assigned the OSError to a variable oe by the keyword as. This allows to access more details when handling this exception. Here we printed the error string oe.strerror and the name of the related file oe.filename. Each error type can have its own set of variables depending on the type. If the file does not exist, in the preceding example, the message will be:

I/O error(2): No such file or directory

On the other hand, if the file exists but you don’t have permission to open it, the message will be:

I/O error(13): Permission denied

This is a useful way to format the output when catching exceptions.

The try  -  except combination can be extended with optional else and finally blocks. An example of using else can be seen in section Testing the bisection algorithm of Chapter 13, Testing. Combining try with finally gives a useful construction when cleanup work needs to happen at the end:

An example for making sure a file is closed properly:

try:
    f = open('data.txt', 'r')
    # some function that does something with the file
    process_file_data(f) 
except: 
    ... 
finally:
    f.close()

This will make sure that the file is closed at the end no matter what exceptions are thrown while processing the file data. Exceptions that are not handled inside the try statement are saved and raised after the finally block. This combination is used in the with statement; see section Context Managers - the with statement.