Exception Handling: try and except

Welcome to another tutorial, here you learn about Exception Handling in Python. 

The concept of Exception Handling is used in Python to handle the exceptions and errors that occur during the execution of any program. In addition, exceptions are unexpected errors that can occur during code execution. 

In coding, Exception occurs, and there can be errors in our code, but why should we spend time handling exceptions? The answer to this question is to develop or possibly improve User Experience. Below are some of the things that occur when an exception occurs.

• The Program execution stops abruptly.
• The complete exception response or message along with the file name and line number of code is printed on the console.
• Also, all the calculations and operations performed till that point in code are lost.

Suppose we have a certain website, and you click on some link to open a webpage, which, for some unknown reason, leads to some exceptions. But, if the exception is not handled, then you will see an exception message while the webpage is also not loaded. 

Therefore, exception handling is crucial in handling errors and displaying an appropriate message to inform the user about the malfunction.

Handling Exceptions using try and except

Two types of blocks that is, the try block and the except block to handle exceptions in Python.

For the try block, the code is written if there are chances of any form of error or possible exception. While the except block is responsible for caching the exception and executing the statements specified inside it.

Check out the example below of dividing a number by zero.

a = 10
b = 0
print("Result of Division: " + str(a/b))

Output:

Traceback (most recent call last):
File "main.py", line 3, in <module>
print("Result of Division: " + str(a/b))
ZeroDivisionError: division by zero

The code in the example above leads to an exception and the exception message is printed as an output on the console.

Now, attempt to use the try and except block, to handle this exception.

# try block
try:
    a = 10
    b = 0
    print("Result of Division: " + str(a/b))
except:
    print("You have divided a number by zero, which is not allowed.")

Output:

You have divided a number by zero, which is not allowed.

The try block

In the code written above, the try block was used to put the whole code that is to be executed in the program which we think might lead to an exception, and so if an exception happens during the execution of the code inside the try block, then it causes the execution of the code to the direction of the except block and the execution that was going on in the try block is executed and the except block is never executed.

The except block

The except block holds the exception cleanup code (i.e. exception has occurred, how can the situation be handled effectively, such as a few print statements used to print some message or maybe to trigger some event or store information in the database, and so on.

In the except block in a code, along with the keyword except. Also, the name of the exception provided that is expected to occur. But, in situations where the exception class name is not provided, it catches all the exceptions, if not it will only catch the exception of the type which is already stated. 

Check out the syntax below.

# except block
except(<Types of Exceptions to catched>):
    # except block starts

Previously, we have stated the types of exceptions, however, it is possible to provide names of multiple exception classes separated by a comma in the except statement.

Code Execution continues after except block

More so, code execution is interrupted in the try block when an exception occurs and the code statements inside the try block after the line which caused the exception are not executed, this is an important aspect of exception to take note of.

In addition, during the running of a code, the execution then jumps into the except block; thereafter the statements inside the except block the code statements after it is executed, similar to any other normal execution.

Check out the example below:

# try block
try:
    a = 10
    b = 0
    print("Result of Division: " + str(a/b))
    print("No! This line will not be executed.")
except:
    print("You have divided a number by zero, which is not allowed.")

# outside the try-except blocks
print("Yo! This line will be executed.")

Output:

You have divided a number by zero, which is not allowed.
Yo! This line will be executed.

Catching Multiple Exceptions in Python

In this case, we have different ways to carry out this. We can either have multiple except blocks with each one handling a specific exception class or handle multiple exception classes in a single except block.

Multiple except blocks

As a programmer, if you suspect that your code may generate different exceptions in different situations and possibly want to handle those exceptions individually, then you can have multiple except blocks.

But, most exceptions occur when inputs from users are involved. 

We will take an example, that will ask a user for two numbers to perform a division operation. We will handle the multiple possible exception case using multiple except blocks.

# try block
try:
    a = int(input("Enter numerator number: "))
    b = int(input("Enter denominator number: "))
    print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ZeroDivisionError):
    print("You have divided a number by zero, which is not allowed.")
# except block handling wrong value type
except(ValueError):
    print("You must enter integer value")

Now, let’s try to run the code above, by providing 0 as the value for the denominator and see the outcome, and then provide some string (i.e a non-integer) value for any variable. Thus, we have handled two cases in the above example.

Handling Multiple Exceptions with on except block

In the example above, we printed different messages based on the exception that occurred. However, if there are no requirements where you have to handle different exceptions individually, you can catch a set of exceptions in a single exception block too.

The code in the example above is shown when rewritten with a single except block.

# try block
try:
    a = int(input("Enter numerator number: "))
    b = int(input("Enter denominator number: "))
    print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ValueError, ZeroDivisionError):
    print("Please check the input value: It should be an integer greater than 0")

In our above example, the two exceptions were handled using a single except block while displaying a meaningful message to the user. 

Generic except block to Handle unknown Exceptions

However, during coding we try to make it error-free by testing it and using exception handling but, there can be some error situations we might not be aware of. Thus, the except blocks can be used to handle specific exception classes. We should always have a generic except block at the end to handle any runtime exceptions or surprise events.

# try block
try:
    a = int(input("Enter numerator number: "))
    b = int(input("Enter denominator number: "))
    print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ZeroDivisionError):
    print("You have divided a number by zero, which is not allowed.")
# except block handling wrong value type
except(ValueError):
    print("You must enter integer value")
# generic except block
except:
    print("Oops! Something went wrong!")

In the above example, the first except block handles the ZeroDivisionError, the second except block will handle the ValueError and subsequent exception that might occur we have the third except block.