Understanding the Differences Between except: and except Exception: in Python

When it comes to exception handling in Python, there are nuances between using except: and except Exception:. This article aims to demystify these differences and provide best practices for effective error handling.

Introduction to Exception Handling

Python's exception handling mechanism is a fundamental part of its programming model, allowing developers to manage errors gracefully. The basic structure of this mechanism involves the try, except, else, and finally blocks. However, the nuances in the except clause can significantly affect the behavior of your program. This article focuses on the two specific cases mentioned in the question: except: and except Exception:.

except:

The except: clause is quite broad and general. When you use this, it catches all exceptions, including those that are system-exiting such as KeyboardInterrupt and SystemExit. This means that if any exception is raised within the try block, it will be caught by except:.

Example

try:
    x  1 / 0
except:
    print("All exceptions caught")

This will output:

All exceptions caught

except Exception:

On the other hand, the except Exception: clause is more specific. It catches exceptions that are derived from the Exception base class. These include most standard exceptions like ValueError and TypeError. However, it does not catch any exceptions that are derived from the BaseException class, such as KeyboardInterrupt and SystemExit. This makes except Exception: a safer and more controlled approach to exception handling.

Example

try:
    x  1 / 0
except Exception as e:
    print(type(e))

This will output:

class 'ZeroDivisionError'

Note that ZeroDivisionError inherits from Exception, but not from BaseException.

Best Practices in Exception Handling

Given the behavior of these two clauses, it is generally recommended to be specific about the exceptions you want to catch. By doing so, you avoid inadvertently catching exceptions that you might not want to suppress. Here are some best practices:

Handling Specific Exceptions

For example, you can catch specific exceptions like this:

try:
    x  1 / 0
except ZeroDivisionError:
    print("Caught a ZeroDivisionError")
except ValueError:
    print("Caught a ValueError")
except TypeError:
    print("Caught a TypeError")

This allows you to handle different types of exceptions appropriately without masking unrelated issues.

System-Exiting Exceptions

For handling system-exiting exceptions, you should be aware that:

- KeyboardInterrupt, SystemExit, and GeneratorExit are caught by except: but not by except Exception:.

- Somewhat oddly, some user-defined exceptions that inherit BaseException (like MyError in the example) will also not be caught by except Exception:.

Example

try:
    while True:
        pass
except Exception as e:
    print(type(e))
except:
    print("All exceptions caught")
sys.exit(0)

And another function:

class MyError(Exception):
    def __init__(self, value):
          value
    def __str__(self):
        return repr()
def func():
    try:
        raise MyError('An error')
    except MyError as e:
        print(e)
    except:
        print("Unknown exception")
def func2():
    try:
        raise MyError('An error')
    except Exception as e:
        print(e)
    except:
        print("Unknown exception")
if __name__  "__main__":
    func()  # This will catch the exception
    func2()  # This will pass through the exception

Conclusion

Understanding the differences between except: and except Exception: is crucial for effective and safe exception handling in Python. While except: is very broad, except Exception: is more specific and generally recommended for handling standard exceptions. Following best practices and being specific about which exceptions to catch will lead to more robust and maintainable code.