Exception chaining in Python - Step-by-Step Execution

Concept Flow - Exception chaining

Start try block

↓

Exception occurs

↓

Catch exception as e

↓

Raise new exception from e

↓

Python links exceptions

↓

Exception chain shown in traceback

When an error happens inside a try block, you catch it and raise a new error using 'from' to link them. Python shows both errors together.

Execution Sample

Python

try:
    x = 1 / 0
except ZeroDivisionError as e:
    raise ValueError("Bad value") from e

This code tries to divide by zero, catches that error, then raises a new error linked to the first one.

Execution Table

Step	Action	Exception Raised	Exception Caught	Exception Chaining	Output/Traceback
1	Execute 'x = 1 / 0'	ZeroDivisionError	No	No	No output yet
2	Catch ZeroDivisionError as e	ZeroDivisionError	ZeroDivisionError caught	No	No output yet
3	Raise ValueError from e	ValueError	ValueError raised	ValueError linked to ZeroDivisionError	Traceback shows both exceptions chained
4	Program stops with chained exceptions	ValueError	No further catch	Chain displayed	Traceback printed with cause

💡 Program stops after raising ValueError chained from ZeroDivisionError

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x	undefined	Error raised, no value assigned	No change	No change	No value due to error
e	undefined	undefined	ZeroDivisionError instance	No change	ZeroDivisionError instance

Key Moments - 3 Insights

Why do we use 'raise ... from e' instead of just 'raise'?

Using 'raise ... from e' links the new exception to the original one, showing both errors in the traceback (see execution_table step 3). Just 'raise' re-raises the same exception without chaining.

What happens if we don't catch the original exception before raising a new one?

If you raise a new exception without catching the original, Python won't link them. The chain only forms when you use 'from' with a caught exception (see execution_table step 2 and 3).

Does the original exception stop the program immediately?

No, the original exception is caught first (step 2), then a new exception is raised (step 3). The program stops only after the new exception is not caught.

Visual Quiz - 3 Questions

Look at the execution table, what exception is caught at step 2?

A ZeroDivisionError

B TypeError

C ValueError

D No exception caught

💡 Hint

Check the 'Exception Caught' column at step 2 in the execution_table.

At which step does Python link the new exception to the original one?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Exception Chaining' column to find when chaining happens.

If we remove 'from e' in the raise statement, what changes in the output?

A The traceback shows both exceptions chained

B The program runs without errors

C The traceback shows only the new exception without the original cause

D The original exception is re-raised instead

💡 Hint

Refer to the explanation in key_moments about 'raise ... from e' usage.

Concept Snapshot

Exception chaining in Python:
Use 'raise NewError() from original_error' inside except block.
This links the new error to the original one.
Traceback shows both exceptions for easier debugging.
Without 'from', only the new error appears.
Helps track error causes clearly.

Full Transcript

This example shows how Python handles exception chaining. When an error happens inside a try block, it is caught in the except block as 'e'. Then a new exception is raised using 'raise ... from e' which links the new exception to the original one. The execution table traces each step: first the ZeroDivisionError occurs, then it is caught, then a ValueError is raised from it. The variable tracker shows that 'x' never gets a value because of the error, and 'e' holds the original exception. Key moments clarify why 'from e' is important to keep the chain visible in the traceback. The visual quiz tests understanding of which exceptions are caught, when chaining happens, and what happens if 'from e' is removed. The concept snapshot summarizes the syntax and purpose of exception chaining in Python.