When using the print() function to output the result of the three function calls (lines 5-7 in the example code above), the first would display 81.28, and the second would produce an AssertionError. As an error has been detected, the third function call on line 7 will be prevented from running (but it would also produce an AssertionError if it was called).

Exceptions

An exception is an event that occurs during the execution (running) of a program that will disrupt the normal flow of the program's instructions. Generally speaking, when a Python program encounters a problem, it will raise an exception. An exception is a Python object representing an error. When a Python program raises an exception, it will need to either handle the exception immediately, otherwise the program will terminate execution and quit.

Handling exceptions

If you have written some code that you suspect could raise an exception, you can protect the program from terminating early (crashing or quitting) by placing the “sketchy” code in a try: block. After the try: block, you will need to include an except: statement, which is then followed by a block of code that will handle the problem in the best way possible.

Example

Let's have a look at an example. We have a function called DivideCookies() which has two parameters:

• numberOfCookies

• numberOfPeople.

The function will work out how to evenly divide cookies between a group of people without worrying about how many cookies are left over. It will use the // floor division operator to get a whole number result and return this value when the function is called.

However, we are a little worried that the program will crash if 0 is provided as the value for numberOfPeople. We can't divide by zero! We want to ensure the program doesn't crash if the program tries to divide a number of cookies amongst 0 people, which would result in a ZeroDivisionError. So, we have a try...except...else statement that will attempt to run the DivideCookies function. If a ZeroDivisionError exception is detected, then it will be handled by displaying a suitable error message and the rest of the program will continue to execute. If all is ok and no ZeroDivisionError exception is detected, then the result of the division will be displayed to the user (in the else statement) and the rest of the program will also continue to run.

In the example below, the first time we call the function, it will cause a ZeroDivisionError error (as 0 has been provided for the numberOfPeople parameter. It will display an error message “Number of people must be greater than 0” rather than just crashing the program. After this, the program will continue to run and will call the function providing the value 2 for the numberOfPeople parameter. The output will be “Number of cookies per person: 2”.

Using the example scenario above, if we didn’t use the try..except..else statements and a ZeroDivisionError was generated, then the entire program would crash and stop running. Obviously, we want to make sure our code is reliable and we should ensure that all types of errors are covered. For example, we should add some input data validation code to ensure that “bad” input can’t even be entered by the user in the first place. It’s not a great idea to patch every problem with a try..except..else statement. However, there are scenarios where exception handling might be needed.

Using the except clause with no exceptions defined

In the example program above, there are a number of things that can go wrong when calling the DivideCookies() function. For example, we could try to divide by zero resulting in an error. We could also try to divide a string value which would also result in an error (eg "a"//2). Or we could even call the function without providing any values for the numberOfCookies and numberOfPeople parameters.

We can actually use the except: clause without specifying a specific type of exception which means that any type of exception will be handled. This is kind of a "catch all" approach. Check out the example below. In this example, no exception has been defined after the except: clause which means that if any type of error is detected, a generic response will be given.

Experiment with the code above by changing the arguments provided for the numberOfCookies and numberOfPeople parameters (eg. provide a string value, or a 0, empty arguments, or incorrect number of arguments). The same generic response will be provided when any type of error is detected and the rest of the code will continue running without the program crashing.

This type of try-except statement catches all of the exceptions that could possibly occur. However, taking this kind of approach is not considered a good programming practice. It might catch all exceptions but it doesn't help the programmer identify and fix the root cause of a problem. The best approach is to write good code that is thoroughly tested and capable of working in a variety of situations.

Using the except clause with multiple exceptions

Another way we can use the except: clause is by specifying multiple exceptions (inside parantheses, separate by commas) to handle more than one exception. Take a look at the example below. This code will handle both a ZeroDivisionError and a TypeError exception, and then display an appropriate message if either of these exceptions are detected.

Experiment with the code above by changing the error types in the except clause (experiment with different types of errors) and changing the values provided as arguments for the function’s parameters. You’ll notice that the code will handle ZeroDivisionError and TypeError errors but if any other type of error is generated, then the program will crash.

The try-finally clause

The finally: block can be used along with a try: block. The finally block is used to contain any code that must execute, regardless of whether the try-block raised an exception or not. In the example below, the print() function on line 11 will always execute, regardless of whether an exception was raised or not.

Capturing an exception's argument

Exceptions can have an argument (a value that gives additional information about the problem) which can be useful when debugging your code. You capture an exception's argument by providing a variable in the except clause as shown in the example below. In this example, the program will attempt to divide 5 by 0 causing an error. A custom message will be displayed identifying the type of error that occurred.

Raising an exception

You can actually raise exceptions in different ways by using the raise statement as shown below. In the example below, we have a function that will take a phone number (stored as a string value) and check if the length of the phone number is not equal to 10 characters. If the phone number is not 10 characters long, then it is not a phone number. We could also check to make sure the phone number only contains digits 0-9 but we won't bother with that here. If the phone number is not 10 characters in length, then an exception will be raised. When the exception is raised, we can use the phoneNumber variable and refer to the exception as InvalidNumber.

In the example above, the following scenarios could occur:

• An invalid phone number (not equal to 10 characters in length) is provided:

  • Only the “Phone number [phone number] is not valid” message will be displayed

• A valid phone number (equal to 10 characters in length) is provided

  • The “The phone number is [phone number]” message will be displayed.

  • The “Bye!” message will also be displayed.

Next lesson: Working with files