Catch multiple exceptions in one line (except block)
From Python 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 using
How do I catch multiple exceptions in one line (except block)
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. The
as keyword is used for the assignment. You can use any name for the error object, I prefer
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, the
err object falls out of scope when the
except block is concluded.
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.
suppress context manager
The accepted answer is really 4 lines of code, minimum:
try: do_something()except (IDontLikeYouException, YouAreBeingMeanException) as e: pass
pass lines can be handled in a single line with the suppress context manager, available in Python 3.4:
from contextlib import suppresswith suppress(IDontLikeYouException, YouAreBeingMeanException): do_something()
So when you want to
pass on certain exceptions, use
trystatement 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 except
ValueError, e:was the syntax used for what is normally written as
except ValueError as e:in modern Python (described below). The old syntax is still supported for backwards compatibility. This means
except RuntimeError, TypeErroris not equivalent to
except (RuntimeError, TypeError):but to
except RuntimeError as
TypeError:which is not what you want.