Python 101 (part 8): An Exceptionally Clever Snake - Anatomy Of An Exception (
Page 2 of 9 )
No developer, no matter how good (s)he is, writes bug-free code all the
time. Which is why most programming languages - including Python - come
with built-in capabilities to catch errors and take remedial action. This
action could be something as simple as displaying an error message, or as
complex as heating your computer's innards until they burst into flame
(just kidding!)
Normally, when a Python program encounters an error, be it syntactical or
logical, it exits the program at that stage itself with a message
indicating the cause of the error. Now, while this behaviour is acceptable
during the development phase, it cannot continue once a Python program has
been released to actual users. In these "live" situations, it is
unprofessional to display cryptic error messages (which are usually
incomprehensible to non-technical users); rather, it is more professional
to intercept these errors and either resolve them (if resolution is
possible), or notify the user with a clear error message (if not).
The term "exceptions" refers to those errors which can be tracked and
controlled. For example, if a function attempts an unsupported operation on
a built-in Python object (say, modifying an immutable object), Python will
generate a "TypeError" exception, together with a stack trace or detailed
explanation of the problem. Exceptions like these can be caught by the
application, and appropriately diverted to an exception-handling routine.
An example might make this clearer. Consider the following Python program,
#!/usr/bin/python
# set up tuple
dessert = ('apple pie', 'chocolate fudge cake', 'icecream')
# change tuple value
dessert[1] = 'chocolate brownies'
which generates a TypeError because I'm trying to modify a tuple.
Traceback (innermost last):
File "dessert.py", line 5, in ?
dessert[1] = 'chocolate brownies'
TypeError: object doesn't support item assignment
Now, let's add some code to trap and handle the exception gracefully.
#!/usr/bin/python
try:
# try running this code
dessert = ('apple pie', 'chocolate fudge cake', 'icecream')
dessert[1] = 'chocolate brownies'
except TypeError:
# if error, do this...
print "Whoops! Something bad just happened. Terminating script."
And this time, when the script is executed, it will not generate a
TypeError - instead, it will output
Whoops! Something bad just happened. Terminating script.
This is a very basic example of how Python exceptions can be trapped, and
appropriate action triggered. As you will see, the ability to handle errors
in a transparent manner throws open some pretty powerful possibilities...
