May 29, 2012 1 Comment
Lady Yes this looks the sort of thing. May I just try it?
Assistant Certainly, madam.
The lady presses button and a sheet of flame shoots out across the hall.
Lady Oh! Sorry! So sorry! (she is happy though) Yes that’s fine.
Assistant Is that on account, madam?
Apparently, in Python, it is easier to ask for forgiveness rather than seek permission. That is to say, the normal approach when writing Python code is to assume that what you are trying to do will work properly. If something exceptional happens and the code doesn’t work the way you were hoping, then the Python interpreter will tell you of the error so that you can handle that exceptional circumstance. This general approach, of trying to do something, then cleaning up if something goes wrong is acronymically called EAFP (“easier to ask for forgiveness than permission. Here is a (somewhat silly) example:
>>> a= 1 >>> b="2" >>> a+b Traceback (most recent call last): File "", line 1, in TypeError: unsupported operand type(s) for +: 'int' and 'str'
What has happened is that we have tried to add a word (ie the string “2”) to a number (the integer 1). Addition doesn’t make any sense in this circumstance, so Python “throws” an “exception”. In this case the exception is called a TypeError. The problem with this is that when an exception is raised, then unless the program deals with the exception, the Python interpreter will step in, stop the program and print an error message like the one above.
Python deals with this by the try/except structure. You try to do the statements in the first block of code, and if there is an exception (that is, you failed when you tried), then you do the statements in the second block of code.
>>> try: ... print a+b # this is the first block of code and can be multiple statements ... except TypeError: ... print "Can't add those things together!" # this is the second block of code ... Can't add those things together!
Can you see that no exception was raised here? As far as the Python interpreter is concerned, everything ran smoothly. The program tried to print a+b, and, in doing so, tried to work out what a +b is. However, it failed because a is a number and b is a string. Because it failed nothing got printed in the first block of code. Also because the specific failure was a TypeError, the second block of code was run.
A short code snippet can show you how this works:
>>> c = [1,"2",2,3,4,5] >>> sumOfc = 0 >>> # Try Number 1 - this will fail >>> for number in c: ... sumOfc += number ... Traceback (most recent call last): File "<stdin>", line 2, in <module> TypeError: unsupported operand type(s) for +=: 'int' and 'str' >>> # Try Number 2 - this will work >>> sumOfc = 0 # need to reset the sum >>> for number in c: ... try: ... sumOfc += number ... except TypeError: ... pass ... >>> sumOfc 15
In the first try, the interpreter ran into the string “2” and didn’t know what to do, so gave up. In the second try, the interpreter knew exactly what to do if there was a problem with the addition (pass – or, in other words “do nothing”[see note 1]) so it went through the whole of the array adding up the things that were numbers without complaining.
Of course, you don’t use try/except blocks around everything. You will usually have an idea about the parts of the code where something goes wrong. You can put that code in a try/except block, with code to deal with a failure. What you shouldn’t ever do is this:
>>> sumOfc = 0 >>> c = [1,"2",2,3,4,5] >>> for number in c: ... try: ... sumOfc += number ... except: # <- Don't do this! ... pass ... >>> sumOfc 15
It is not entirely obvious what is wrong here – the code works just as well as before. The only difference is in the except line – there is no exception specified. The reason that this is bad isn’t that the code doesn’t work well, but, rather, that it works too well. Every exception will be caught here, not just the one that you were expecting. This is bad because if some other problem arises in your try block, you’ll never learn about it and your exception code will probably deal with it incorrectly. You won’t know why your program doesn’t work because the interpreter won’t tell you.
The other approach to dealing with possible errors is called Look Before You Leap (LBYL). LBYL involves making sure everything is right before you actually do the thing you do the problematic operation. So, for example, you might check that what you were trying to add was an integer:
>>> c = [1,"2",2,3,4,5] >>> sumOfc = 0 >>> for number in c: ... if isinstance(number,int): ... sumOfc += number ... >>> sumOfc 15
Here the isinstance() function is another feature of Python introspection. It tests whether the variable number is an integer (“int”). So this code doesn’t even bother trying to add the number unless its an integer. It first checks “is this an integer I see before me?” If so, it adds it, if not, it ignores it. Which is fine as far as it goes…
The problem with this is that it’s the wrong way around. You’re not really interested in whether or not the thing you’re adding is an integer. Rather, you’re interested in knowing whether addition is meaningful [see note 2]. In fact, this way of approaching things is broken:
>>> c = [1,"2",2,3,4,5.2] >>> sumOfc = 0 >>> for number in c: ... if isinstance(number,int): ... sumOfc += number ... >>> sumOfc 10
We’ve changed the last number in the array to be 5.2, but this causes it to be ignored because it isn’t an integer – ooops! Applying the earlier try/except code gives the right result though:
>>> c = [1,"2",2,3,4,5.2] >>> sumOfc = 0 >>> for number in c: ... try: ... sumOfc += number ... except TypeError: ... pass ... >>> sumOfc 15.199999999999999
Well, accurate up to the rounding error… Our try/except code gave us floating point addition for “free”, where the LBYL failed. In fact, it’s even more interesting because how it works is dependent on what we define sumOfc to be:
>>> sumOfc = '' >>> for number in c: ... try: ... sumOfc += number ... except TypeError: ... pass ... >>> sumOfc '2'
Wow! If that didn’t make you giddy with excitement, I don’t know what will. The same code works if we make sumOfc a string. Implicitly then we’re asking Python to join the strings (which is what + means for a string) together and ignore stuff that can’t be joined. We got this entirely for free from our try/except structure, something that would have needed reworking in the LBYL. In fact, we could use this structure for any object that has addition defined for it. It’s this sort of clever which makes Python so good.
Normally the place to use exceptions is where, every once in a while, something out of the ordinary will happen and you have some idea about how it will be out of the ordinary. In the first case, if it’s not unusual then it’s not exceptional – don’t handle it with exceptions. In the second case, if you can’t identify how it will be out of the ordinary you can’t deal with it in your except block.
1. The point of the except block is to deal with any problems in the try block. In this case you might try to convert the value to an integer in order that it could be added.
2. Implicitly we’re talking here about breaking interfaces. You, as a programmer, shouldn’t be concerned with what is going on under the hood. You should be able to rely on the fact that an addition method is defined for an object. If it is, then you ought to be able to use it without having to know the internal details of the object. So in the example here, addition is meaningful between integers and floating point numbers, but addition is also meaningful between two strings.