23.8. The try statement: Anticipate exceptions

23.8. The `try` statement: Anticipate exceptions

The purpose of a “try” construct is to specify what actions to take in the event of errors. For an introduction to Python's exception mechanism, see Section 25, “Exceptions: Error signaling and handling”.

When an exception is raised, two items are associated with it:

An exception type, and
an exception value.

Here is the most general form of a try construct. Symbols like B₀ and B₁ represent indented blocks of statements. Each except clause names some exception class E_i (or a tuple of exception classes), and optionally a variable v_i that will be set to the exception value.

try:
    B₀
except E₁ [as v₁]:
    B₁
except E₂ [as v₂]:
    B₂
except ...:
    ...
else:
    B_e
finally:
    B_f

The else: and finally: blocks are optional. There must be at least one except block, but there may be any number.

Here is a simplified description of the execution of a try block in general:

If B₀ executes without raising any exceptions, the else block B_e is executed, then the finally block B_f.
If the execution of block B₀ raises some exception with type E₀, that type is compared against each except clause until one of them matches the raised exception or there are no more except clauses.
The matching condition is slightly complicated: for some clause “except E_i as v_i:”, expression E_i is either an exception class or a tuple of exception classes.
- If E_i is a single class, it is considered a match if E₀ is either the same class as E_i or a subclass of E_i.
- If E_i is a tuple of exception classes, the raised exception is compared to each to see if it is the same class or a subclass, as in the single-class case.
If multiple except clauses match, the first matching clause is said to handle the exception. The corresponding variable v_i (if present) is bound to the raised exception instance, and control passes to the corresponding block B_i.
If there is a finally clause, it is executed, whether the exception was caught or not. If the exception was not caught, it is re-raised after the end of the finally clause.

Examples:

>>> try:
...     raise ValueError("Strike three!")
... except IOError as x:
...     print "I/O error caught:", x
... except ValueError as x:
...     print "Value error caught:", x
... except SyntaxError as x:
...     print "Syntax error caught:", x
... else:
...     print "This is the else clause"
... finally:
...     print "This is the finally clause"
... 
Value error caught: Strike three!
This is the finally clause
>>> try:
...     raise ValueError("Uncaught!")
... except IOError as x:
...     print "I/O error:", x
... else:
...     print "This is the else clause"
... finally:
...     print "This is the finally clause"
... 
This is the finally clause
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ValueError: Uncaught!
>>> try:
...     print "No exceptions raised"
... except ValueError as x:
...     print "ValueError:", x
... else:
...     print "This is the else clause"
... finally:
...     print "This is the finally clause"
... 
No exceptions raised
This is the else clause
This is the finally clause

For those of you who are interested in the gory details, the fun begins when a second or even a third exception is raised inside an except, else, or finally clause. The results are well-defined, and here is a pseudocode description of the edge cases. In this procedure, we'll use two internal variables named pending and detail.

Set pending to None.
Attempt to execute block B₀. If this block raises an exception E₀ with detail d₀, set pending to E₀ and set detail to d₀.
If pending is None, go to Step 8.
Find the first block except E_i, v_i: such that issubclass(E₀, E_i ).
If there is no such match, go to Step 10.
Set v_i to detail.
Attempt to execute block B_i.
If this block raises some new exception E_n with detail d_n, set pending to E_n and set detail to d_n.
However, if block B_i executes without exception, set pending to None. In this case, the original exception is said to have been caught or handled.
Go to Step 10.
If there is no else: clause, go to Step 10.
Attempt to execute the else: block B_e.
If this block raises some new exception E_n with detail d_n, set pending to E_n and set detail to d_n.
If there is no finally: clause, proceed to Step 12.
Attempt to execute the finally: block E_f.
If this block raises some new exception E_n with detail d_n, set pending to E_n and set detail to d_n.
If pending is not None, re-raise the exception as in this statement:
```
raise pending, detail
```
If pending is None, fall through to the statement following the try: block.

Python 2.7 quick reference

23.8. The try statement: Anticipate exceptions

23.8. The `try` statement: Anticipate exceptions