How to prevent "too broad exception" in this case?

Question

I have a list of functions that may fail and, if one fails, I don't want the script to stop, but to continue with next function.

I am executing it with something like this :

list_of_functions = [f_a, f_b, f_c] for current_function in list_of_functions:     try:         current_function()     except Exception:         print(traceback.format_exc()) 

It's working fine, but it is not PEP8 compliant:

When catching exceptions, mention specific exceptions whenever possible instead of using a bare except: clause.

For example, use:

try:     import platform_specific_module except ImportError:     platform_specific_module = None 

A bare except: clause will catch SystemExit and KeyboardInterrupt exceptions, making it harder to interrupt a program with Control-C, and can disguise other problems. If you want to catch all exceptions that signal program errors, use except Exception: (bare except is equivalent to except BaseException: ).

A good rule of thumb is to limit use of bare 'except' clauses to two cases:

If the exception handler will be printing out or logging the traceback; at least the user will be aware that an error has occurred.

If the code needs to do some cleanup work, but then lets the exception propagate upwards with raise . try...finally can be a better way to handle this case.

How can I do this the good way?

Answer 1

The PEP8 guide you quote suggests that it is okay to use a bare exception in your case provided you are logging the errors. I would think that you should cover as many exceptions as you can/know how to deal with and then log the rest and pass, e.g.

import logging  list_of_functions = [f_a,f_b,f_c] for current_function in list_of_functions:     try:         current_function()     except KnownException:         raise     except Exception as e:         logging.exception(e) 

Answer 2

Use this to cheat PEP8:

try:     """code"""  except (Exception,):      pass