python捕获一些异常

Question

I have some code that is calling several methods from multiple functions. Some of these methods may raise an exception. Each can raise a different type of exception. In my main script, I would like to log the exception and then just exit. So, no matter what the exception type, log it and exit

My question is this: is it better to list all the exceptions that might be generated, or just catch a generic Exception? Which is more pythonic?

example:

try:
    some_stuff()
except (Exc1, Exc2, Exc3) as exc:
    loger.exception(exc)

or this:

try:
    some_stuff()
except Exception as exc:
    loger.exception(exc)

Answer 1

Your plan to catch exception in main code, log it and terminate is good one.

There could be exceptions, which are fine and do not mean, you shall consider them as problem, eg KeyboardInterrupt

The strategy could be:

• first, catch all the exceptions, which you expect to be fine and pass
• then catch general Exception , log it and terminate.

The code could look like:

try:
    some(stuff) # ...
# First, resolve expected exceptions
except KeyboardInterrupt:
    pass
# Finally, log unexpected ones
except Exception as exc:
    logger.exception(exc)
    return # time to terminate

When is catching exceptions explicitly a failure

The advice to be better by explicitly catching all expected exceptions comes short in case an unexpected exception happens. Your plan to catch whatever comes to log file sounds good and provide enough information for resolving the problems later on.

Imagine, you have a daemon, which shall run and run. Under some conditions, it might fail.

With only expecting explicit exception, it may happen, unexpected exception happens, no expect would have a chance to log this to a log file, stacktrace would be printed to stdout and forgotten and program terminates.

This is clear and very reasonable use case for catching exception generally.

Answer 2

From the documentation :

Because except: catches all exceptions, including SystemExit, KeyboardInterrupt, and GeneratorExit (which is not an error and should not normally be caught by user code), using a bare except: is almost never a good idea. In situations where you need to catch all “normal” errors, such as in a framework that runs callbacks, you can catch the base class for all normal exceptions, Exception. Unfortunately in Python 2.x it is
possible for third-party code to raise exceptions that do not inherit from Exception, so in Python 2.x there are some cases where you may have to use a bare except: and manually > re-raise the exceptions you don't want to catch.

In general, it is better to catch explicit exceptions. In Python 2, how you are doing it can result in exceptions you still don't catch if an external module is throwing something that doesn't inherit exception.

By catching explicit exceptions you are able to handle errors you know can occur. If you catch all, your application could do something unexpected and you may handle it incorrectly.

Additionally, do you really want to catch someone using Ctrl+C to end your program?

Answer 3

In all languages, times, and places it is better to specify specific exceptions. That way you won't mask a condition you didn't expect to. NEVER catch Exception in production code unless you have a very, very good reason, or your handler is truly generic. An example of a suitably generic handler is one which logs, performs cleanup, and reraises.

Answer 4

Take a note out of Tim Peter's book:

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
...

Explicit is better than implicit. It's more "pythonic" to write out the possible exceptions.