FromPython Documentation:

An except clause may name multiple exceptions as a parenthesized tuple, for example

except (IDontLikeYouException, YouAreBeingMeanException) as e:    pass

Or, for Python 2 only:

except (IDontLikeYouException, YouAreBeingMeanException), e:    pass

Separating the exception from the variable with a comma will still work in Python 2.6 and 2.7, but is now deprecated and does not work in Python 3; now you should be usingas.

How do I catch multiple exceptions in one line (except block)

Do this:

try:    may_raise_specific_errors():except (SpecificErrorOne, SpecificErrorTwo) as error:    handle(error) # might log or have some other default behavior...

The parentheses are required due to older syntax that used the commas to assign the error object to a name. Theas keyword is used for the assignment. You can use any name for the error object, I prefererror personally.

Best Practice

To do this in a manner currently and forward compatible with Python, you need to separate the Exceptions with commas and wrap them with parentheses to differentiate from earlier syntax that assigned the exception instance to a variable name by following the Exception type to be caught with a comma.

Here's an example of simple usage:

import systry:    mainstuff()except (KeyboardInterrupt, EOFError): # the parens are necessary    sys.exit(0)

I'm specifying only these exceptions to avoid hiding bugs, which if I encounter I expect the full stack trace from.

This is documented here:https://docs.python.org/tutorial/errors.html

You can assign the exception to a variable, (e is common, but you might prefer a more verbose variable if you have long exception handling or your IDE only highlights selections larger than that, as mine does.) The instance has an args attribute. Here is an example:

import systry:    mainstuff()except (KeyboardInterrupt, EOFError) as err:     print(err)    print(err.args)    sys.exit(0)

Note that in Python 3, theerr object falls out of scope when theexcept block is concluded.

Deprecated

You may see code that assigns the error with a comma. This usage, the only form available in Python 2.5 and earlier, is deprecated, and if you wish your code to be forward compatible in Python 3, you should update the syntax to use the new form:

import systry:    mainstuff()except (KeyboardInterrupt, EOFError), err: # don't do this in Python 2.6+    print err    print err.args    sys.exit(0)

If you see the comma name assignment in your codebase, and you're using Python 2.5 or higher, switch to the new way of doing it so your code remains compatible when you upgrade.

Thesuppress context manager

The accepted answer is really 4 lines of code, minimum:

try:    do_something()except (IDontLikeYouException, YouAreBeingMeanException) as e:    pass

Thetry,except,pass lines can be handled in a single line with thesuppress context manager, available in Python 3.4:

from contextlib import suppresswith suppress(IDontLikeYouException, YouAreBeingMeanException):     do_something()

So when you want topass on certain exceptions, usesuppress.

FromPython documentation -> 8.3 Handling Exceptions:

Atry 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, for example:

except (RuntimeError, TypeError, NameError):    pass

Note that the parentheses around this tuple are required, because exceptValueError, e: was the syntax used for what is normally written asexcept ValueError as e: in modern Python (described below). The old syntax is still supported for backwards compatibility. This meansexcept RuntimeError, TypeError is not equivalent toexcept (RuntimeError, TypeError): but toexcept RuntimeError asTypeError: which is not what you want.

If you frequently use a large number of exceptions, you can predefine a tuple, so you don't have to retype them many times.

# This example code is a technique I use in a library# that connects with websites to gather dataConnectErrs = (URLError, SSLError, SocketTimeoutError, BadStatusLine, ConnectionResetError)def connect(url, data):    # Do a connection and return some data    return(received_data)def some_function(var_a, var_b, ...):    try: o = connect(url, data)    except ConnectErrs as e:        # Do the recovery stuff    blah # Do normal stuff you would do if an exception does not occur

Notes:

1. If you, also, need to catch other exceptions than those in thepre-defined tuple, you will need to define another except block.

2. If you just cannot tolerate a global variable, define it in main()and pass it around where needed...

One of the ways to do this is...

try:   You do your operations here;   ......................except(Exception1[, Exception2[,...ExceptionN]]]):   If there is any exception from the given exception list,   then execute this block.   ......................else:   If there isn't any exception, then execute this block.

And another way is to create a method which performs a task executed by anexcept block and call it through all of theexcept blocks that you write...

try:   You do your operations here;   ......................except Exception1:    functionname(parameterList)except Exception2:    functionname(parameterList)except Exception3:    functionname(parameterList)else:   If there isn't any exception, then execute this block.def functionname( parameters ):   // Your task..   return [expression]

I know that second one is not the best way to do this, but I'm just showing number of ways to do this thing.

As of Python 3.11 you can take advantage of theexcept* clause that is used to handle multiple exceptions.

PEP-654 introduced a new standard exception type calledExceptionGroup that corresponds to a group of exceptions that are being propagated together. TheExceptionGroup can be handled using a newexcept* syntax. The* symbol indicates that multiple exceptions can be handled by eachexcept* clause.

For example, you can handle multiple exceptions

try:    raise ExceptionGroup('Example ExceptionGroup', (        TypeError('Example TypeError'),        ValueError('Example ValueError'),        KeyError('Example KeyError'),        AttributeError('Example AttributeError')    ))except* TypeError:    ...except* ValueError as e:    ...except* (KeyError, AttributeError) as e:    ...

For more details seeException Groups andexcept-* in the official python docs.

The historic PEP isPEP-654.

• python
• exception