And Finally . . . in Font

Generator PDF417 in Font And Finally . . .

Finally, there is the finally clause. You use it to do housekeeping after a possible exception. It is combined with a try clause: x = None try: x = 1/0

finally: print 'Cleaning up...' del x In the preceding example, you are guaranteed that the finally clause will be executed, no matter what exceptions occur in the try clause. The reason for initializing x before the try clause is that otherwise it would never be assigned a value because of the ZeroDivisionError. This would lead to an exception when using del on it within the finally clause, which you wouldn t catch. If you run this, the cleanup comes before the program crashes and burns: Cleaning up... Traceback (most recent call last): File "C:\python\div.py", line 4, in x = 1/0 ZeroDivisionError: integer division or modulo by zero While using del to remove a variable is a rather silly kind of cleanup, the finally clause may be quite useful for closing files or network sockets and the like. (More on those in 14.) You can also combine try, except, finally, and else (or just three of them) in a single statement: try: 1/0 except NameError: print "Unknown variable" else: print "That went well!" finally: print "Cleaning up."

Note In Python versions prior to 2.5, the finally clause had to be used on its own it couldn t be used

in the same try statement as an except clause. If you wanted both, you needed to wrap two statements. From Python 2.5 onwards, you can combine these to your heart s content, though.

Exceptions and functions work together quite naturally. If an exception is raised inside a function, and isn t handled there, it propagates (bubbles up) to the place where the function was called. If it isn t handled there either, it continues propagating until it reaches the main program (the global scope), and if there is no exception handler there, the program halts with a stack trace. Let s take a look at an example: >>> def faulty(): ... raise Exception('Something is wrong') ...

>>> def ignore_exception(): ... faulty() ... >>> def handle_exception(): ... try: ... faulty() ... except: ... print 'Exception handled' ... >>> ignore_exception() Traceback (most recent call last): File '<stdin>', line 1, in File '<stdin>', line 2, in ignore_exception File '<stdin>', line 2, in faulty Exception: Something is wrong >>> handle_exception() Exception handled As you can see, the exception raised in faulty propagates through faulty and ignore_exception, and finally causes a stack trace. Similarly, it propagates through to handle_exception, but there it is handled with a try/except statement.

Exception handling isn t very complicated. If you know that some part of your code may cause a certain kind of exception, and you don t simply want your program to terminate with a stack trace if and when that happens, then you add the necessary try/except or try/finally statements (or some combination thereof) to deal with it, as needed. Sometimes, you can accomplish the same thing with conditional statements as you can with exception handling, but the conditional statements will probably end up being less natural and less readable. On the other hand, some things that might seem like natural applications of if/else may in fact be implemented much better with try/except. Let s take a look at a couple of examples. Let s say you have a dictionary and you want to print the value stored under a specific key, if it is there. If it isn t there, you don t want to do anything. The code might be something like this: def describePerson(person): print 'Description of', person['name'] print 'Age:', person['age'] if 'occupation' in person: print 'Occupation:', person['occupation']