How to Catch Multiple Exceptions in Python

How to Catch One of Several Possible Python Exceptions

Catching individual exceptions in separate except clauses is the way to go if you need to perform different handling actions on the different exceptions being caught. If you find that you’re performing the same actions in response to different exceptions, then you can produce simpler, more readable code by handling multiple exceptions in a single except clause. To do this, you specify the exceptions as a tuple within the except statement.

Suppose you now like the idea of your earlier code being able to handle both exceptions in a single line. To do this, you decide to rewrite your code as follows:

# multiple_exceptions.py

try:
    first = float(input("What is your first number? "))
    second = float(input("What is your second number? "))
    print(f"{first} divided by {second} is {first / second}")
except (ValueError, ZeroDivisionError):
    print("There was an error")

This time, if you catch either a ValueError or ZeroDivisionError exception, you handle it with the same except clause. You also could’ve included additional except clauses for other exceptions if you wanted to. These would’ve worked for you in the same way as before.

You can then test this version of your code using the same test cases as before:

$ python multiple_exceptions.py
What is your first number? 10
What is your second number? 5
10.0 divided by 5.0 is 2.0

$ python multiple_exceptions.py
What is your first number? 10
What is your second number? "five"
There was an error

$ python multiple_exceptions.py
What is your first number? 10
What is your second number? 0
There was an error

In your first test, only your try block gets executed because you don’t raise any exceptions. Your second and third test cases raise a ValueError and ZeroDivisionError, respectively. You’ve caught each of them in the same except clause. In both cases, the program flow is try then except (ValueError, ZeroDivisionError). Again, your code survives the exceptions without crashing.

Although you’re happy that the handler safely handles both exceptions in the same way, you’d like to know exactly which exception is being raised. You’ll learn how to do this next.

Identify Which Python Exception Was Caught

If you’re familiar with object-oriented programming concepts, then you know that classes are templates that define the content and abilities of the objects that you create, or instantiate, from them. When your code raises a Python exception, it actually instantiates an object from the class that defines the exception. For example, when you raise a ValueError exception, you’re instantiating an instance of the ValueError class.

While you don’t need a thorough knowledge of object-oriented programming to work with exceptions, you should be aware that different exception objects only exist because they’re instantiated from different classes.

You decide to try and identify the individual exceptions caught in your previous code:

# exception_identification.py

try:
    first = float(input("What is your first number? "))
    second = float(input("What is your second number? "))
    print(f"{first} divided by {second} is {first / second}")
except (ValueError, ZeroDivisionError) as error:
    print(f"A {type(error).__name__} has occurred.")

Here, you’ve made some adjustments to the handler. It still catches both ValueError and ZeroDivisionError exceptions, but this time, you assign the exception object to a variable named error. Doing this allows you to analyze it.

To find the class of an Exception, you use type(). If you print the .__name__ attribute of the class, then you see exactly which exception your code has handled. Now you can find out which exceptions have occurred:

$ python exception_identification.py
What is your first number? 10
What is your second number? 5
10.0 divided by 4.0 is 2.0

$ python exception_identification.py
What is your first number? 10
What is your second number? "five"
A ValueError has occurred.

$ python exception_identification.py
What is your first number? 10
What is your second number? 0
A ZeroDivisionError has occurred.

The first test is a relief because it proves that your update still works. The second and third tests raise exceptions. As you can see, your code has correctly identified both the ValueError and ZeroDivisionError exceptions.

Suppose you decide to improve your code by allowing multiplication. You also decide to manually raise a RuntimeError if your user requests an unsupported operation or does something unexpected, like entering a carriage return:

# exception_identification_with_structural_pattern_matching.py

from operator import mul, truediv

def calculate(operator, operand1, operand2):
    return operator(operand1, operand2)

try:
    first = float(input("What is your first number? "))
    second = float(input("What is your second number? "))
    operation = input("Enter either * or /: ")
    if operation == "*":
        answer = calculate(mul, first, second)
    elif operation == "/":
        answer = calculate(truediv, first, second)
    else:
        raise RuntimeError(f"'{operation}' is an unsupported operation")
except (RuntimeError, ValueError, ZeroDivisionError) as error:
    print(f"A {type(error).__name__} has occurred")
    match error:
        case RuntimeError():
            print(f"You have entered an invalid symbol: {error}")
        case ValueError():
            print(f"You have not entered a number: {error}")
        case ZeroDivisionError():
            print(f"You can't divide by zero: {error}")
else:
    print(f"{first} {operation} {second} = {answer}")

This time, you use the operator module’s mul() and truediv() functions to perform multiplication and division. You pass these to your calculate() function, along with two numbers. Your calculate() function then calls the operator module function that you’ve passed to it, which performs the calculation. This only works if you enter in two numbers and either / or * for the operation.

Although you could’ve coded calculate() to use the * or / operator directly, using an operator module function simplifies the function’s code and provides extensibility.

If your user enters an invalid operator, then your code explicitly raises a RuntimeError. Like any other exception, this will cause the code to crash if you don’t handle it.

The except clause of your handler again contains a tuple of exceptions that you want to catch. You reference the exception, as before, by a variable named error. First, your handler prints the name of the exception class, regardless of the exception raised. Then, you use the match block to print a message based on the specific exception being handled.

You opt for structural pattern matching instead of many elif clauses for neatness. The exception that your error variable references is compared to the various case clauses. Only the first matching case block executes, and the rest are ignored. The chosen case block then prints a message followed by error. The inclusion of error in your f-string prints the exception’s default traceback message for more context.

If the try clause raises no more exceptions, then your program ignores the except clause, and control passes to the else clause. You use it here to print the answer of the calculation.

Now you retest calculate() with normal inputs:

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? 4
Enter either * or /: /
10.0 / 4.0 = 2.5

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? 5
Enter either * or /: *
10.0 * 5.0 = 50.0

As you see, the division still works, and so does the new multiplication capability. Expand the section below to see what happens when you create exceptions.

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? 5
Enter either * or /: +
A RuntimeError has occurred
You have entered an invalid symbol: '+' is an unsupported operation

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? 5
Enter either * or /:
A RuntimeError has occurred
You have entered an invalid symbol: '' is an unsupported operation

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? "five"
A ValueError has occurred
You have not entered a number: could not convert string to float: '"five"'

$ python exception_identification_with_structural_pattern_matching.py
What is your first number? 10
What is your second number? 0
Enter either * or /: /
A ZeroDivisionError has occurred
You can't divide by zero: float division by zero

Now that you know how to identify different Exception objects using their classes, next you’ll learn how to use Python’s exception hierarchy to simplify the handling of exceptions by handling their parent exception instead.

Catch One of Multiple Possible Python Exceptions Using Its Superclass

You’ve already learned how different exceptions are objects instantiated from different classes. These classes all belong to the Python exception class hierarchy. All Python exceptions inherit from a class named BaseException, and one of these subclasses is the Exception class. This is the superclass of all of the exceptions that you’ll learn about in this tutorial.

Python contains over sixty different exceptions. The diagram below illustrates only a few, but it does contain all the Exception subclasses that you’ll cover in this tutorial. Indeed, these are some of the common exceptions that you’re likely to encounter:

The chart shows that Exception is the superclass of all other exceptions. Subclasses of Exception inherit everything that Exception contains. Usually, subclasses extend their inherited members to differentiate themselves. In the case of exceptions, inheritance is mostly about creating an exception hierarchy. As you can see, ArithmeticError is a subclass of Exception. Internally, the differences between them are negligible.

You can also see two of the subclasses of the OSError class, namely PermissionError and FileNotFoundError. Again, this means that both PermissionError and FileNotFoundError are actually subclasses of OSError. By implication, both are also Exception subclasses because OSError inherits from Exception.

You can use the fact that a subclass is a variant of its superclass to your advantage to capture different exceptions. Suppose you write the following:

# file_fault.py

from os import strerror

try:
    with open("datafile.txt", mode="rt") as f:
        print(f.readlines())