Programmers are not wizards. As a part of our journey, we make errors and mistakes all the time. Its normal and and expected. Even for a seasoned developer like me, errors are just a natural part of programming. But knowing how to properly address and handle these errors is what makes us good programmers. In today’s post, I am going to discuss exception handling in Python. Whether you’re a Python newbie or an experienced programmer, understanding how to manage exceptions is a skill you can’t afford to ignore. So let’s get started!

An older version of this same guide: Exception Handling in Python with Examples

What is Exception Handling in Python?

First, what is an exception? Exceptions are events, issues or errors that occur during runtime or the execution of a program. And, exception handling in python is the process of catching and resolving these issues without affecting a program’s flow.

For example, when you try dividing a number by zero or try to open a file that doesn’t exist, your program will throw exceptions. But being able to handle these exceptions properly will ensure that your program or application can run smoothly during unexpected scenarios.

You may like: The Ultimate Python Cheat Sheet – An Essential Reference for Python Developers

Why Exception Handling in Python is Crucial

Imagine a situation where a program processes hundreds of user files. One file is corrupted. Without exception handling, your program crashes, leaving users frustrated. And with the help of Python’s exception handling features, you can easily isolate the problematic file and continue to process other files without disrupting the flow of your program.

To farther clarify, here are some important reasons why exception handling in Python is crucial:

• Prevents abrupt program crashes.
• Improves user experience.
• Simplifies debugging by isolating problematic code.
• Ensures critical functionalities of an applications are working properly.

Types of Errors in Python

There are two types of errors in Python:

• Syntax errors: These errors occur when the code doesn’t follow Python’s syntax rules.
• Logical errors (Exceptions): These are errors during runtime when something unexpected occurs.

Syntax Errors

Whenever your code or the structure of your code violates Python’s rules, a syntax error occurs. For example, observe the following snippet::

The above code will not execute due to the syntax error in the conditional statement.

How to handle it?

Handling syntax errors is entirely up to the programmer. By carefully understanding Python’s syntax, you can avoid such mistakes. Syntax errors are typically caught during the compilation phase, so the programmer will know about them before the code runs.

Logical Errors (Exceptions)

Logical errors, commonly known as exceptions, occur during the execution of the program. These exceptions are triggered when there’s an issue with the program’s logic or operations. For instance, dividing a number by zero will cause an exception.

Let’s look at an example:

This will raise a ZeroDivisionError.

Unlike syntax errors, logical errors allow the program to start execution, but it stops abruptly when the exception is encountered. To ensure smooth execution, we need to handle these exceptions properly.

How Exception Handling in Python Works

Python provides a structured way to manage exceptions using the try, except, else, and finally blocks.

• try block: Allows you to attempt risky operations.
• except block: To catch and handle errors.
• else block: Execute code when there are no exceptions.
• finally block: Perform clean up tasks.

Before diving into how exceptions can be handled, let’s briefly discuss Python’s sys module.

The sys Module

The sys module provides access to special variables and functions that interact with the Python interpreter. One such function is sys.exc_info(), which returns a tuple containing information about the exception being raised.

The tuple contains:

• Type of the exception (e.g., ZeroDivisionError).
• Value: A description of the error.
• Traceback: The call stack when the exception occurred.

We’ll use sys.exc_info() in the coming examples to illustrate exception handling

Using Try-Except in Python

The try and except blocks as I like to call it the ‘bread and butter’ of exception handling. These two blocks form the foundation of exception handling in Python. The try block contains the code that might throw an exception or error. If an exception occurs, control is passed to the except block, allowing the program to handle the error gracefully without breaking the flow.

For example:

When you execute this code, Python will catch the ZeroDivisionError and prevents the program from crashing.

Output:

Error occurred: <class 'ZeroDivisionError'>

If you are following along, go ahead and run the code and see what you get.

Iterative Exception Handling Example

Let’s expand on exception handling with a loop:

Explanation:

• Each iteration runs within the try block
• If an exception occurs, the except block handles it and prints the error type.

Output:

The value of x is: 5.0
Error occurred: <class 'TypeError'>
Error occurred: <class 'ZeroDivisionError'>
The value of x is: 2.0
Error occurred: <class 'TypeError'>

Handling Specific Exceptions

It’s good practice to handle specific exceptions rather than catching all errors with a general except block.

This approach provides tailored error messages for different exceptions.

Here is the output to the previous code:

The value of x is: 5.0
The type of 'i' is not valid.
Cannot divide by zero.
The value of x is: 2.0
The type of 'i' is not valid.

Combining Exceptions in a Single Block

Output:

The value of x is: 5.0
TypeError or ZeroDivisionError occurred.
TypeError or ZeroDivisionError occurred.
The value of x is: 2.0
TypeError or ZeroDivisionError occurred.

Using the else Block

The else block executes when no exceptions are raised in the try block. It’s useful for separating critical operations from additional logic.

Output:

The value of x is: 5.0
The type of 'i' is not valid.
Cannot divide by zero.
The value of x is: 2.0
The type of 'i' is not valid.

Raising Exceptions Manually

You can raise exceptions manually using the raise keyword. This is helpful when you need to enforce constraints in your code depending on special circumstances.

Output:

('Even number encountered:', 2)
('Even number encountered:', 4)
('Even number encountered:', 6)
List with odd numbers: [1, 3, 5]

Using the finally Block

The finally block runs regardless of whether an exception occurred or not. It’s ideal for cleanup tasks like closing files or releasing resources.

Output:

The value of x is: 5.0
Iteration ends here...
The type of 'i' is not valid.
Iteration ends here...
Cannot divide by zero.
Iteration ends here...
The value of x is: 2.0
Iteration ends here...
The type of 'i' is not valid.
Iteration ends here...

In-built Exceptions

We have raised three exceptions so far:

• ValueError,
• TypeError
• ZeroDivisionError.

These exceptions are in-built exceptions, meaning they are already part of Python’s built-in library. They are raised automatically. Apart from these three, there are several other in-built exceptions in Python. Let’s discuss some other common exceptions:

• IndentationError: Raised when indentation is not correct.
• SystemError: Raised when an internal error is detected by the system.
• IndexError: Raised when the index is out of range.
• KeyError: Raised when the key is not present in the dictionary.
• NameError: Raised when the variable name is not found.
• MemoryError: Raised when memory runs out during an operation.
• ImportError: Raised when a module being imported is not found.
• AssertionError: Raised when an assert statement fails to execute.
• OverflowError: Raised when an arithmetic operation produces a result that exceeds the maximum limit.
• UnicodeError: Raised when an error related to Unicode encoding or decoding occurs.

Things to Remember

Handling errors and exceptions is necessary, and they should be managed with care. Let’s discuss some of the points you should keep in mind while handling exceptions in Python:

1. Place the critical code, which may raise errors and exceptions, inside the try block.
2. Never use a single except block to handle all exceptions. There should be specific except blocks to handle individual exceptions.
3. Avoid adding anything unrelated to the critical code in the try block. Instead, attach an else block to execute statements if no exception is raised in the try block.

You may like:

• The Ultimate Python Cheat Sheet – An Essential Reference for Python Developers
• Building a Web App with Python – Getting Started With Flask

Conclusion

I think I’ve covered pretty much all the basic stuff when it comes to exception handling in Python. If you are a new to handling errors in Python, then this guide should give you a pretty good start.

Also read: 150 Python Interview Questions You Should Know in 2024

Always remember that errors and exceptions are an unavoidable part of programming. However, Python provides robust tools to manage and handle them. By using exception handling in Python, you can ensure your programs run smoothly even when the unexpected happens. Take the time to learn and implement these techniques, and your code will thank you.

What strategies do you use for exception handling in your Python projects? Let’s discuss below!