What is exception chaining?

Exception chaining in Python is a mechanism that allows linking one exception to another. When a new exception occurs during the handling of another exception, Python automatically links the new exception as __cause__ of the previous one. This preserves the context of the original problem.

Key points:

• Automatic chaining: Happens by default when an exception occurs in except or finally blocks.
• Manual chaining: Can be performed using the syntax raise new_exception from original_exception.
• __cause__ attribute: Contains a reference to the exception that caused the current exception.
• __context__ attribute: Contains a reference to the exception that was being handled when the current exception occurred. Used if __cause__ is not set.
• Traceback: The full traceback includes information from all linked exceptions.

Example of manual chaining:

# Custom exception example
class CustomError(Exception):
    pass

# Function that may raise an error
def divide_by_zero(a, b):
    try:
        return a / b
    except ZeroDivisionError as e:
        # Manual chaining
        raise CustomError("Division by zero occurred") from e

# Calling the function and handling the exception
try:
    divide_by_zero(10, 0)
except CustomError as e:
    # Printing chained exception information
    print(f"Caught CustomError: {e}")
    if e.__cause__:
        print(f"Original cause: {e.__cause__}")

Advantages:

• Improved debugging: Easier to trace the chain of events leading to the error.
• Preservation of context: The exception information helps understand the original cause.
• Cleaner code: No need for nested try...except blocks to preserve context.

Using raise ... from ... vs automatic chaining:

Aspect	raise new_exc from original_exc	Automatic chaining (in except/finally)
Link	Explicitly sets new_exc.__cause__ = original_exc.	Sets new_exc.__context__ = original_exc.
In Traceback	Explicitly shows "The above exception was the direct cause of ..."	Shows "During handling of the above exception, another exception occurred:"
Purpose	Clearly indicates that original_exc caused new_exc.	Indicates an error that occurred during handling of original_exc.

Exception chaining is an important tool for creating robust and easily debuggable Python code.