16.8. The try statement: Anticipate exceptions

16.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 18, “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, and optionally a variable v_i that will be set to the exception value.

try:
    B₀
except E₁[, v₁]:
    B₁
except E₂[, 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 to all the exception classes E₁, E₂, ... named in the various except clauses.
The criterion for matching is that E₀ must be the same class as, or some subclass of, one of the class names E_i mentioned in an except clause. If there are multiple matches, the first except clause block B_iis executed. In this case, we say that the exception has been caught (or handled).
When an except block matches and is entered, the corresponding variable v_i is set to the value of the exception.
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, "Your arm's off."
... except IOError, detail:
...     print "I/O error caught:", detail
... except ValueError, detail:
...     print "Value error caught:", detail
... except SyntaxError, detail:
...     print "Syntax error caught:", detail
... else:
...     print "This is the else clause"
... finally:
...     print "This is the finally clause"
... 
Value error caught: Your arm's off.
This is the finally clause
>>> try:
...     raise ValueError, "Uncaught!"
... except IOError, detail:
...     print "I/O error:", detail
... 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, 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.5 quick reference

16.8. The try statement: Anticipate exceptions

16.8. The `try` statement: Anticipate exceptions