The text and code are released under the CC0 license; see also the companion project, the Python Data Science Handbook.
No matter your skill as a programmer, you will eventually make a coding mistake. Such mistakes come in three basic flavors:
Here we're going to focus on how to deal cleanly with runtime errors. As we'll see, Python handles runtime errors via its exception handling framework.
In [3]:
print(Q)
Or if you try an operation that's not defined:
In [4]:
1 + 'abc'
Or you might be trying to compute a mathematically ill-defined result:
In [5]:
2 / 0
Or maybe you're trying to access a sequence element that doesn't exist:
In [6]:
L = [1, 2, 3]
L[1000]
Note that in each case, Python is kind enough to not simply indicate that an error happened, but to spit out a meaningful exception that includes information about what exactly went wrong, along with the exact line of code where the error happened. Having access to meaningful errors like this is immensely useful when trying to trace the root of problems in your code.
In [7]:
try:
print("this gets executed first")
except:
print("this gets executed only if there is an error")
Note that the second block here did not get executed: this is because the first block did not return an error.
Let's put a problematic statement in the try block and see what happens:
In [8]:
try:
print("let's try something:")
x = 1 / 0 # ZeroDivisionError
except:
print("something bad happened!")
Here we see that when the error was raised in the try statement (in this case, a ZeroDivisionError), the error was caught, and the except statement was executed.
One way this is often used is to check user input within a function or another piece of code. For example, we might wish to have a function that catches zero-division and returns some other value, perhaps a suitably large number like $10^{100}$:
In [9]:
def safe_divide(a, b):
try:
return a / b
except:
return 1E100
In [10]:
safe_divide(1, 2)
Out[10]:
In [11]:
safe_divide(2, 0)
Out[11]:
There is a subtle problem with this code, though: what happens when another type of exception comes up? For example, this is probably not what we intended:
In [12]:
safe_divide (1, '2')
Out[12]:
Dividing an integer and a string raises a TypeError, which our over-zealous code caught and assumed was a ZeroDivisionError!
For this reason, it's nearly always a better idea to catch exceptions explicitly:
In [13]:
def safe_divide(a, b):
try:
return a / b
except ZeroDivisionError:
return 1E100
In [14]:
safe_divide(1, 0)
Out[14]:
In [15]:
safe_divide(1, '2')
We're now catching zero-division errors only, and letting all other errors pass through un-modified.
raiseWe've seen how valuable it is to have informative exceptions when using parts of the Python language. It's equally valuable to make use of informative exceptions within the code you write, so that users of your code (foremost yourself!) can figure out what caused their errors.
The way you raise your own exceptions is with the raise statement. For example:
In [16]:
raise RuntimeError("my error message")
As an example of where this might be useful, let's return to our fibonacci function that we defined previously:
In [17]:
def fibonacci(N):
L = []
a, b = 0, 1
while len(L) < N:
a, b = b, a + b
L.append(a)
return L
One potential problem here is that the input value could be negative.
This will not currently cause any error in our function, but we might want to let the user know that a negative N is not supported.
Errors stemming from invalid parameter values, by convention, lead to a ValueError being raised:
In [18]:
def fibonacci(N):
if N < 0:
raise ValueError("N must be non-negative")
L = []
a, b = 0, 1
while len(L) < N:
a, b = b, a + b
L.append(a)
return L
In [19]:
fibonacci(10)
Out[19]:
In [20]:
fibonacci(-10)
Now the user knows exactly why the input is invalid, and could even use a try...except block to handle it!
In [21]:
N = -10
try:
print("trying this...")
print(fibonacci(N))
except ValueError:
print("Bad value: need to do something else")
In [22]:
try:
x = 1 / 0
except ZeroDivisionError as err:
print("Error class is: ", type(err))
print("Error message is:", err)
With this pattern, you can further customize the exception handling of your function.
In [23]:
class MySpecialError(ValueError):
pass
raise MySpecialError("here's the message")
This would allow you to use a try...except block that only catches this type of error:
In [24]:
try:
print("do something")
raise MySpecialError("[informative error message here]")
except MySpecialError:
print("do something else")
You might find this useful as you develop more customized code.
In [25]:
try:
print("try something here")
except:
print("this happens only if it fails")
else:
print("this happens only if it succeeds")
finally:
print("this happens no matter what")
The utility of else here is clear, but what's the point of finally?
Well, the finally clause really is executed no matter what: I usually see it used to do some sort of cleanup after an operation completes.