I know that I can do:
try: # do something that may fail except: # do this if ANYTHING goes wrong
I can also do this:
try: # do something that may fail except IDontLikeYouException: # say please except YouAreTooShortException: # stand on a ladder
But if I want to do the same thing inside two different exceptions, the best I can think of right now is to do this:
try: # do something that may fail except IDontLikeYouException: # say please except YouAreBeingMeanException: # say please
Is there any way that I can do something like this (since the action to take in both exceptions is to
try: # do something that may fail except IDontLikeYouException, YouAreBeingMeanException: # say please
Now, this really won’t work, as it matches the syntax for:
try: # do something that may fail except Exception, e: # say please
So, my effort to catch the two distinct exceptions doesn’t exactly come through.
Is there a way to do this?
How to catch multiple exceptions in one line in Python?
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 to catch multiple exceptions in one line (except block)? Answer #2:
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 sys try: 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.
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 sys try: 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 sys try: 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 suppress with suppress(IDontLikeYouException, YouAreBeingMeanException): do_something()
So when you want to
pass on certain exceptions, use
If you frequently use a large number of exceptions, you can pre-define a tuple, so you don’t have to re-type them many times.
#This example code is a technique I use in a library that connects with websites to gather data ConnectErrs = (URLError, SSLError, SocketTimeoutError, BadStatusLine, ConnectionResetError) def connect(url, data): #do 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 no exception occurred
- If you, also, need to catch other exceptions than those in the pre-defined tuple, you will need to define another except block.
- 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 is no exception then execute this block.
and another way is to create a method that performs task executed by
except block and call it through all of the
except block that you write:
try: You do your operations here; ...................... except Exception1: functionname(parameterList) except Exception2: functionname(parameterList) except Exception3: functionname(parameterList) else: If there is no exception then execute this block. def functionname( parameters ): //your task.. return [expression]
I know that the second one is not the best way to do this, but I’m just showing number of ways to do this thing.
Hope you learned something from this post.
Follow Programming Articles for more!