• Post author:
  • Post category:Python
  • Post last modified:March 27, 2024
  • Reading time:5 mins read
You are currently viewing Python Catch Multiple Exceptions

How to catch multiple exceptions in Python? Handling exceptions is an essential part of writing robust and error-free Python code. You might often come across situations where your code needs to handle multiple exceptions at once. In such cases, catching each exception type in a separate except block can be time-consuming and repetitive.

Python provides several ways to catch multiple exceptions in a single block, making your code more concise and efficient. In this article, we will explore different approaches for catching multiple exceptions and how to choose the best one for your code.

1. Quick Examples of Catching Multiple Exceptions

These quick examples provide a glimpse into the various ways you can catch multiple exceptions. We will discuss them in more detail.


# Example 1: Using a Tuple of Exception Types:
try:
    pass
except (TypeError, ValueError) as e:
    # handle the exception

# Example 2: Using Separate except Blocks:
try:
    pass
except TypeError as e:
    # handle the TypeError exception
except ValueError as e:
    # handle the ValueError exception

# Example 3: Using a List of Exception Types:
try:
    pass
except [TypeError, ValueError] as e:
    # handle the exception

2. Catching Multiple Exceptions using a List

Using a list of exception types you can catch multiple exceptions in a single except block in Python. This method is similar to using a tuple of exception types, but it allows you to easily add or remove exception types as needed.


# Catch multiple exception using list
try:
    # Code that raise Exception
except [TypeError, ValueError] as e:
    print("An exception occurred:", e)

3. Catching Multiple Exceptions with Tuple

Using a tuple of exception types is a simple and concise way to catch multiple exceptions in a single except block in Python. When an exception occurs in the try block, Python checks if the exception is an instance of any of the exception types listed in the tuple. If so, the corresponding except block is executed.


# Catch multiple exception using tuple
try:
    # Code that raise Exception
except (TypeError, ValueError) as e:
    print("An exception occurred:", e)

4. Using Multiple Except Blocks

Using separate except blocks is another way to catch multiple exceptions in Python. This method allows you to handle different exception types in different ways, making it ideal when you need to perform specific actions for each type of exception.


# Using multiple except blocks
try:
    # Code that raise Exception
except TypeError as e:
    print("TypeError occurred:", e)
except ValueError as e:
    print("ValueError occurred:", e)

5. Catching Base Exceptions

Using the base Exception class is another approach for catching multiple exceptions in Python. The Exception class is the base class for all built-in exceptions in Python, so by catching Exception, you can handle any type of exception that might occur in your code.


# Using base Exception class
try:
    # Code that raise Exception
except Exception as e:
    print("An exception occurred:", e)

6. Using a Dictionary for Exception Handling:

Using a dictionary to map exceptions to handlers is another technique for handling multiple exceptions in Python. This method is particularly useful when you have a large number of exception types to handle and want to avoid writing long chains of if/elif statements or multiple except blocks.


def handle_type_error(e):
    print("TypeError occurred:", e)

def handle_value_error(e):
    print("ValueError occurred:", e)

handlers = {
    TypeError: handle_type_error,
    ValueError: handle_value_error
}

try:
    # Code that raise Exception
except Exception as e:
    if type(e) in handlers:
        handlers[type(e)](e)
    else:
        raise e

7. Summary and Conclusion

We have explored multiple ways to catch multiple exceptions in Python. Each of these approaches has its own advantages and disadvantages, and the choice of which one to use depends on the specific needs of your code. I hope this article has been helpful. If you have any questions, please don’t hesitate to leave a comment below.

Happy Coding!

AlixaProDev

I am an astute software engineer with extensive 3+ years of experience in developing full-stack web applications. My skillets include building backend services for different databases. Mainly I work with Python, Flask, Django, and FastAPIs. Being Python Specialist, I have worked with Numpy, Pandas, and other Python Libraries to build tools that make ETL normalization easier.