From Zero To Hero In Handling Python Exceptions

No code is perfect. No matter how expert you are at programming, once in a while an error will occur. For beginners, this is more common. One area of errors that beginners encounter are syntax errors. These are errors that occur due to the fact that the programmer did not follow one of the rules of the language. In whatever IDE you are working with, syntax errors are usually highlighted so that the programmer can learn from them. We will not be talking about syntax errors in this post. Rather our focus will be on another type of error that occurs in programming, and that is exceptions.

 

Exceptions are errors that are detected during the execution of the program. They are different from syntax errors. They disrupt the normal operation of the program and tends to make the program produce results that are, though not fatal, unintended by the programmer. In python, there are standard ways of handling exceptions and we will discuss on those ways.

All exceptions in python have a type, and that type derives from a parent class, the BaseException class. If you go to the python documentation page on exceptions, you will realize that there are so many documented exceptions in python and ways to handle them. You can take a look at the various ones. But we will be discussing on only a representative few.

As we have said before, when a code contains lines that would cause unusual execution in the program, such as asking for a division by zero, an exception will be raised. When an exception is raised if it is not handled, python will ask the program to stop execution. Therefore, it is in our best interest to catch and handle exceptions if we want our programs to run to the end.

Let’s look at some examples of common exceptions you must have already encountered in your programs: ZeroDivisionError and IndexError.

A ZeroDivisionError is raised when the denominator for a division or modulus operation is zero. Because you cannot divide by zero, this is an error in the code that must have to be handled, otherwise python will stop execution of the program. If it is not handled, python will stop execution and print out a stack traceback report, indicating where the exception happened and the type of the exception. Let’s take an example to illustrate this. Just run the code below.

The code has a list of denominators we want to use to divide the numerator, 20. It runs well until the denominator becomes 0 and we run into an exception. Because the exception is not handled, python stops execution of the program and prints out a stack traceback of the exception so the programmer can understand where it occurred.

Now, let’s talk about the IndexError exception. IndexError exceptions are raised when a sequence subscript is out of range. Remember that the index for a sequence starts from zero to length of the sequence minus 1, so if we call for an index that is out of that range, an IndexError exception is raised. Here is an example.

When we called for the fourth fruit, it raised an error which was not handled and the program had to stop execution. Notice the message in the stack traceback. It gives the type of exception and what caused the exception to happen.

How to handle exceptions in python.

When you notice that a line of code might result in an error, you can handle it using that try…except…else…finally blocks. I will describe each of them in turn. But here is how they would be arranged in code.

try:
    # place relevant code that you expect
    # will result in an error here
except ExceptionErrorToCatch:
    # place code to handle the exception here
else:
    # place code for what to do after 
    # the code runs successfully at 
    # try block
finally:
    # place clean up code here 

The try block:

The try block is where you place the code that can raise an exception. More than one type of exception can occur at the try block but they can all be handled at the except block area.

The except block:

At the except block is where you place code that will handle the exception After the except statement you state the exception error that you want to handle or catch. It could be a ZeroDivisionError, IndexError, AttributeError etc. You just state it here. You could decide to handle all the exceptions separately and so this means you can write more than one except statement, but if you decide to use the same code to handle all the exceptions coming from the try statement, then you will denote the exceptions you are catching one after the other in a single except statement and separate them using a comma. For example, if your code will result in a ValueError or ZeroDivisonError, you could handle them in the following ways:

try:
    m = int(input()) #expect ValueError here
    n = 20/m         #Expect ZeroDivisionError here
except (ZeroDivisionError, ValueError):
    print('Exception handled here')    

You can see the both exceptions I was expecting were placed in a tuple. You use code like this to handle more than one exception at the same time. But if you want to handle each exception separately, you could use the code below:

try:
    m = int(input()) #expect ValueError here
    n = 20/m         #Expect ZeroDivisionError here
except ZeroDivisionError:
    print('ZeroDivisionError exception handled here')
except ValueError:
    print('ValueError exception handled here')        

Some people use a generic Exception clause when handling exceptions and I would encourage you not to do so. When handling exceptions be specific as to the type of exception you want to handle.

Note: when the statements in the try block are run, if no exception occurs, then the except block is not triggered, instead it is skipped. And that is when you come to the else block.

The else block:

In case you want to run some code if no exception was raised in the try blocks or statement, then you would use an else block to write the code. The else block continues execution when no exception was realized in the try statement. But if an exception is realized, python uses the except blocks to try to handle the exception. Here is some code that illustrates the use of the try…except…else statements. It will ask you to input a number of your choice when you run it.

Try running the above code with the following scenarios to see how the try…except…else statements with work. When the program asks for your input, first 1. Insert a zero to see how the exception will be handled. 2. Second, insert something that is not a number, like a string, ‘mmj’, to see how it handles the exception where something that is not a number is entered. 3. Enter a valid number to see what is printed out. You will notice that the code in the else block is executed when a valid number is entered.

Finally, there is a fourth block we have not discussed, the finally block.

The finally block.

The finally block is an optional block. It is used to clean up resources after the try block and other blocks have been run. No matter what happens in the code, whether an exception is raised or not, the finally block is called last before the program leaves the exception handling area. Note that if an exception occurs during the try block and it is not handled, python will re-raise the exception again after it has run the finally block. Exceptions can also sometimes occur during execution of the except clause, it will be re-raised again after the execution of the statements in the finally block.

Let’s demonstrate an example of how finally block can be used.

Try to run the scenarios again that I gave in the else paragraph to see how the finally block will be run. It is executed every time, whether an exception is raised or not. Whenever you are using up resources, or opening and writing to files, you use the finally block to do clean up of those resources.

The Arguments of an Exception:

Sometimes, we might want to retrieve the additional information that comes with the exception. That is when we supply the arguments variable when specifying the exception(s) in the except block. You state the arguments variable after specifying the name of the exception. In the code below, I used the keyword, as, to separate the exception name from the argument, I then referenced the argument in the exception handling code.

Raising an Exception

What if, as a programmer, you want to raise an exception when a condition is breached. For example, instead of waiting for python to detect the exception in the division by zero case above, you want to check if the user inputted zero yourself. You can raise an exception to handle that error yourself. You raise an exception by calling the raise statement like this: raise ExceptionName(argument). The argument could be optional.

Here is some example:

In line 3, I checked on the condition that the user entered 0 and if that is the case, I raised an exception which was handled by the except block in lines 5 and 6. Notice that I supplied an argument to the exception when I raised it and that argument was retrieved when the exception was handled for informative debugging. Try running the code above using two scenarios: 1. Enter 0 on input to see how it will run. 2. Enter a number on input to see how it skips the conditional in the try statement without raising an exception and goes to the else block. Please, don’t enter a non-number; I'm not handling that exception.

So, you have all you need to work with exceptions. I wish you get creative and start experimenting with them. In case you want further information on exceptions and how to handle them, you can reference the python documentation page on exceptions here.