Now that we have substantial knowledge of Python, let’s look at one very important thing with software: error handling. Like most other languages, Python also provides error handling with exceptions. Let’s have a look in how this works.

Error handling with Exceptions

Basically, each progress of error-handling starts with a try-statement. This is a block where an error might occur. If an error occurs in the try-block, an exception is raised in Python. The interpreter then looks if there is a surrounding exception handler. It is best to handle exceptions as detailed as possible, since it will prevent errors later in the program. Python has a huge list of pre-defined exceptions, so it is easy to handle them without the need for own exceptions. A try-Block might also have a finally-block. This is useful if you worked with files or opened some connections. In the finally-block, you can close the connections. Note that the finally-block is executed every time, independent of an error or not. The syntax for Exceptions is this:

try:
TRY-BLOCK
except ERRORNAME:
ERROR-BLOCK
finally:
FINAL-BLOCK

If you look for exceptions in the Python documentation, you have to look them up with the “Error” appending. Python doesn’t call them “Exceptions” – even though the base-class is called like that. In the following sample, we will create a division by zero error. Therefore, we define a method “divide” which takes two parameters. We surround the division with the try-statement and check for the ZeroDivisionError. Note that the finally block is executed in all calls to the method.

def divide(val1, val2):
    try:
        return val1 / val2
    except ZeroDivisionError:
        print("Division by zero - return 0 instead")
        return 0
    finally:
        print("Cleanup everything")
        
res = divide(2, 3)
res2 = divide(2, 0)
print("The result for res is: " + str(res) + " and for res2 it is: " + str(res2))

Output:

Cleanup everything
Division by zero - return 0 instead
Cleanup everything
The result for res is: 0.6666666666666666 and for res2 it is: 0

So, this was easy, wasn’t it? Now, let’s have a look at how to raise your own exceptions.

Creating own exceptions

Basically, an exception can be “thrown” with the “raise” statement. Python is much more modest with that. C-like languages throw exceptions at you, whereas Python just kindly raises one ;). The statement to raise an exception is written like this:

raise ERRORNAME:

In our next sample, we want to raise an error for a car that drives too fast. Therefore, we first need to create our own exception. All exceptions inherit from “Exception”. So, we first create a class that inherits from that. We call the error “TooFastError”. We add no further functionality and just write pass. This instructs Python to continue with other logic. We then define a function “accelerate”, which gets exactly one parameter – speed. If speed is higher than 100, we now raise our TooFastError. Let’s try it:

class TooFastError(Exception):
    pass
def accelerate(speed):
    if speed > 100:
        raise TooFastError("You can't drive at " + str(speed) + " the overall speed limit is 100!")
    else:
        print("Ok, let's go!")
    
accelerate(20)
accelerate(110)

Output:

Ok, let's go!
TooFastErrorTraceback (most recent call last)
<ipython-input-8-9be2666bf1f4> in <module>
      9 
     10 accelerate(20)
---> 11 accelerate(110)
<ipython-input-8-9be2666bf1f4> in accelerate(speed)
      4 def accelerate(speed):
      5     if speed > 100:
----> 6         raise TooFastError("You can't drive at " + str(speed) + " the overall speed limit is 100!")
      7     else:
      8         print("Ok, let's go!")
TooFastError: You can't drive at 110 the overall speed limit is 100!

Isn’t it beautiful to raise your own exceptions :)? In our next tutorial we will have a look at decorators in Python and at the Dataclass.

0 replies

Leave a Reply

Want to join the discussion?
Feel free to contribute!