Python handle multiple exceptions

How to Catch Multiple Exceptions in Python

A well developed application must always be capable of handling unexpected events — such as exceptions — in a proper way. This is also important when it comes to debugging your source code during development, but also when it comes to inspecting the application logs when the application is up and running (eventually in production).

In today’s short tutorial we will showcase how one can handle multiple Exceptions in Python. We will also explore some new features in Python that can help you do so in a more intuitive and clean way. Let’s get started!

For Python < 3.11

Now let’s suppose that we have the following (fairly dumb) code snippet, that raises AttributeError , ValueError and TypeError .

def my_function(x): 
if x == 1: 
raise AttributeError('Example AttributeError') 
elif x == 2: 
raise ValueError('Example ValueError') 
elif x == 3: 
raise TypeError('Example TypeError') 
else: 
print('Hello World')

And let’s also suppose that we want to to call the function my_function but at the same time, we also need to ensure that we handle any unexpected errors appropriately. To do so, we can use the try-except clauses.

But let’s assume that we want to perform a certain action if an AttributeError is being thrown and a different action when either of ValueError or TypeError are raised by my_function .

try: 
my_function(x)
except AttributeError: 
# Do something 
. 
except (ValueError, TypeError): 
# Do something else 
. 

A try statement may have more than one except clause, to specify handlers for different exceptions. At most one handler will be executed. Handlers only handle exceptions that occur in the corresponding try clause, not in other handlers of the same try statement. An except clause may name multiple exceptions as a parenthesized tuple.

— Python Docs

If you are not planning to do anything special with any of the errors being raised (e.g. you just pass ) you can even use the suppress Context Manager as illustrated below:

Источник

How to Catch Multiple Exceptions in Python

When a program encounters an exception during execution, it is terminated if the exception is not handled. By handling multiple exceptions, a program can respond to different exceptions without terminating it.

In Python, try-except blocks can be used to catch and respond to one or multiple exceptions. In cases where a process raises more than one possible exception, they can all be handled using a single except clause.

There are several approaches for handling multiple exceptions in Python, the most common of which are discussed below.

Using Same Code Block for Multiple Exceptions

With this approach, the same code block is executed if any of the listed exceptions occurs. Here’s an example:

try: name = 'Bob' name += 5 except (NameError, TypeError) as error: print(error) rollbar.report_exc_info()

In the above example, the code in the except block will be executed if any of the listed exceptions occurs. Running the above code raises a TypeError , which is handled by the code, producing the following output:

cannot concatenate 'str' and 'int' objects

Using Different Code Blocks for Multiple Exceptions

If some exceptions need to be handled differently, they can be placed in their own except clause:

try: name = 'Bob' name += 5 except NameError as ne: # Code to handle NameError print(ne) rollbar.report_exc_info() except TypeError as te: # Code to handle TypeError print(te) rollbar.report_exc_info()

In the above example, NameError and TypeError are two possible exceptions in the code, which are handled differently in their own except blocks.

Investigating Exceptions using If, Elif, Else Statements

Exceptions can also be checked using if-elif-else conditions, which can be useful if the exception needs to be investigated further:

import errno try: f = open('/opt/tmp/myfile.txt') except IOError as e: rollbar.report_exc_info() if e.errno == errno.ENOENT: print('File not found') elif e.errno == errno.EACCES: print('Permission denied') else: print e

Here, the variable e holds an instance of the raised IOError . The additional status code of the exception is checked in the if , elif and else blocks and the first match is executed:

Multiple Except Clauses Matching

There may be cases where a piece of code causes an exception that can match multiple except clauses:

try: f = open('/opt/tmp/myfile.txt') except EnvironmentError: rollbar.report_exc_info() print('Failed to open file') except IOError: rollbar.report_exc_info() print('File not found')

Since EnvironmentError is more general than IOError , it matches the exception in the code above. The EnvironmentError except clause is listed first, so the code within it gets executed, producing the following output:

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Python errors easier than ever. Sign Up Today!

Related Resources

How to Handle Unhashable Type List Exceptions in Python

How to Throw Exceptions in Python

«Rollbar allows us to go from alerting to impact analysis and resolution in a matter of minutes. Without it we would be flying blind.»

Источник

Python Multiple Exception Handling Read it later

Exception handling is an essential part of any programming language, including Python. It helps in detecting errors and handling them in a way that prevents the program from crashing. Python allows handling multiple exceptions at once, which means a single try block can have multiple except blocks. This blog will guide you through the basics of Python multiple exception handling and how to use it effectively.

What are exceptions in Python?

In Python, an exception is an event that interrupts the normal flow of a program. It occurs when the program encounters an error that it cannot handle. An exception can be raised due to various reasons, such as incorrect user input, file not found, network connection issues, etc.

Why is exception handling important?

Exception handling is crucial in programming for the following reasons:

1. Prevents program crashes: When a program encounters an exception, it can lead to a crash. Exception handling prevents this from happening by gracefully handling the error.
2. Debugging: Exception handling provides information about the error, which can be useful in debugging the program.
3. User Experience: Exception handling improves the user experience by providing meaningful error messages.

Basic Exception Handling in Python

The basic syntax for handling exceptions in Python is as follows:

try: # Block of code to be monitored for exceptions except ExceptionType: # Code to handle the exception 

In the above code, the try block contains the code that may raise an exception. The except block contains the code to handle the exception. If an exception occurs in the try block, Python looks for the corresponding except block to handle the exception.

Here’s an example of basic exception handling in Python:

try: num1 = int(input("Enter a number: ")) num2 = int(input("Enter another number: ")) result = num1 / num2 print(result) except ZeroDivisionError: print("Cannot divide by zero") except ValueError: print("Please enter a valid number") 

In the above code, the program prompts the user to enter two numbers and divides them. If the user enters a zero for the second number, a ZeroDivisionError exception is raised. If the user enters a non-numeric value, a ValueError exception is raised. The corresponding except block handles each exception by providing a meaningful error message.

Multiple Exception Handling in Python

Python allows handling multiple exceptions in a single try block. This means that a single try block can have multiple except blocks to handle different types of exceptions. The syntax for handling multiple exceptions is as follows:

try: # Block of code to be monitored for exceptions except (ExceptionType1, ExceptionType2): # Code to handle the exception 

Here’s an example of multiple exception handling in Python:

try: num1 = int(input("Enter a number: ")) num2 = int(input("Enter another number: ")) result = num1 / num2 print(result) except (ZeroDivisionError, ValueError): print("Please enter valid numbers and ensure that the second number is not zero.") 

In the above code, the program prompts the user to enter two numbers and divides them. If the user enters a zero for the second number or a non-numeric value, the corresponding exception is raised. The except block handles both exceptions by providing a single error message.

Handling Specific Exceptions in Python

In addition to handling multiple exceptions, Python allows handling specific exceptions using separate except blocks. This is useful when you want to handle different types of exceptions differently. The syntax for handling specific exceptions is as follows:

try: # Block of code to be monitored for exceptions except ExceptionType1: # Code to handle ExceptionType1 except ExceptionType2: # Code to handle ExceptionType2 

Here’s an example of handling specific exceptions in Python:

try: num1 = int(input("Enter a number: ")) num2 = int(input("Enter another number: ")) result = num1 / num2 print(result) except ZeroDivisionError: print("Cannot divide by zero") except ValueError: print("Please enter a valid number") except: print("An error occurred") 

In the above code, the program prompts the user to enter two numbers and divides them. If the user enters a zero for the second number, a ZeroDivisionError exception is raised. If the user enters a non-numeric value, a ValueError exception is raised. The program also has a generic except block that handles any other exception.

Python Nested Exception Handling

Python allows nesting try-except blocks to handle exceptions in a more granular way. This is useful when you want to handle exceptions at different levels of the program. The syntax for nested exception handling is as follows:

try: # Outer try block try: # Inner try block # Block of code to be monitored for exceptions except ExceptionType1: # Code to handle ExceptionType1 except ExceptionType2: # Code to handle ExceptionType2 except Exception: # Code to handle Exception 

Here’s an example of nested exception handling in Python:

try: # Outer try block num1 = int(input("Enter a number: ")) try: # Inner try block num2 = int(input("Enter another number: ")) try: # Innermost try block result = num1 / num2 print(result) except ZeroDivisionError: print("Cannot divide by zero") except ValueError: print("Please enter a valid number") except: print("An error occurred") 

In the above code, the program prompts the user to enter two numbers and divides them. The outer try block handles any exception that occurs while getting the first number. The inner try block handles any exception that occurs while getting the second number. The innermost try block handles the division and any ZeroDivisionError exception that may occur.

Raising Exceptions in Python

In addition to handling exceptions, Python allows raising exceptions to indicate an error in the program. This can be useful when you want to stop the program’s execution and provide a custom error message. The syntax for raising exceptions is as follows:

raise ExceptionType("Error message")

Here’s an example of raising an exception in Python:

try: age = int(input("Enter your age: ")) if age < 0: raise ValueError("Age cannot be negative") except ValueError as e: print(e)

In the above code, the program prompts the user to enter their age. If the user enters a negative value, a ValueError exception is raised with a custom error message.

Exception Handling in Python Best Practices

To ensure effective exception handling in your Python programs, here are some best practices to follow:

Источник