8. Errors and Exceptions

Until now error messages haven't been more than mentioned, but if you
have tried out the examples you have probably seen some. There are
(at least) two distinguishable kinds of errors:
syntax errors and exceptions.

8.1 Syntax Errors

Syntax errors, also known as parsing errors, are perhaps the most common
kind of complaint you get while you are still learning Python:

The parser repeats the offending line and displays a little `arrow'
pointing at the earliest point in the line where the error was
detected. The error is caused by (or at least detected at) the token
preceding the arrow: in the example, the error is detected at
the keyword print, since a colon (":") is missing
before it. File name and line number are printed so you know where to
look in case the input came from a script.

8.2 Exceptions

Even if a statement or expression is syntactically correct, it may
cause an error when an attempt is made to execute it.
Errors detected during execution are called exceptions and are
not unconditionally fatal: you will soon learn how to handle them in
Python programs. Most exceptions are not handled by programs,
however, and result in error messages as shown here:

The last line of the error message indicates what happened.
Exceptions come in different types, and the type is printed as part of
the message: the types in the example are
ZeroDivisionError, NameError and
TypeError.
The string printed as the exception type is the name of the built-in
name for the exception that occurred. This is true for all built-in
exceptions, but need not be true for user-defined exceptions (although
it is a useful convention).
Standard exception names are built-in identifiers (not reserved
keywords).

The rest of the line is a detail whose interpretation depends on the
exception type; its meaning is dependent on the exception type.

The preceding part of the error message shows the context where the
exception happened, in the form of a stack backtrace.
In general it contains a stack backtrace listing source lines; however,
it will not display lines read from standard input.

8.3 Handling Exceptions

It is possible to write programs that handle selected exceptions.
Look at the following example, which asks the user for input until a
valid integer has been entered, but allows the user to interrupt the
program (using Control-C or whatever the operating system
supports); note that a user-generated interruption is signalled by
raising the KeyboardInterrupt exception.

First, the try clause (the statement(s) between the
try and except keywords) is executed.

If no exception occurs, the except clause is skipped and
execution of the try statement is finished.

If an exception occurs during execution of the try clause, the rest of
the clause is skipped. Then if its type matches the exception named
after the except keyword, the rest of the try clause is
skipped, the except clause is executed, and then execution continues
after the try statement.

If an exception occurs which does not match the exception named in the
except clause, it is passed on to outer try statements; if
no handler is found, it is an unhandled exception and execution
stops with a message as shown above.

A try statement may have more than one except clause, to
specify handlers for different exceptions. At most one handler will
be executed. Handlers only handle exceptions that occur in the
corresponding try clause, not in other handlers of the same
try statement. An except clause may name multiple exceptions
as a parenthesized list, e.g.:

... except (RuntimeError, TypeError, NameError):
... pass

The last except clause may omit the exception name(s), to serve as a
wildcard. Use this with extreme caution, since it is easy to mask a
real programming error in this way! It can also be used to print an
error message and then re-raise the exception (allowing a caller to
handle the exception as well):

The try ... except statement has an optional
else clause, which, when present, must follow all except
clauses. It is useful for code that must be executed if the try
clause does not raise an exception. For example:

The use of the else clause is better than adding additional
code to the try clause because it avoids accidentally
catching an exception that wasn't raised by the code being protected
by the try ... except statement.

When an exception occurs, it may have an associated value, also known as
the exception's argument.
The presence and type of the argument depend on the exception type.
For exception types which have an argument, the except clause may
specify a variable after the exception name (or list) to receive the
argument's value, as follows:

A finally clause is executed whether or not an exception has
occurred in the try clause. When an exception has occurred, it is
re-raised after the finally clause is executed. The finally clause is
also executed ``on the way out'' when the try statement is
left via a break or return statement.

A try statement must either have one or more except clauses
or one finally clause, but not both.