The Optional `else` in Python’s `try` Statement
This post discusses the else
clause in Python’s try
statement. Although this particular use of else
may not be as forgotten and controversial as its use in Python loops, a gentle reminder of how it works and when it’s useful may still be beneficial. Please note that this post only focuses on the else
clause of the try
statement and does not intend to cover the entire try
statement. For a pretty good initial explanation of how the entire try
statement works, refer to the official Python documentation on this topic.
A “normal” stripped down try
statement seen regularly looks something like this:
try:
# some code that might raise exception
except:
# code to handle exception
finally:
# code to run regardless of exception
This is “normal” in the sense that to anyone coming from most other programming languages can understand/guess what it means:
- Some code will be tried to be executed.
- If an exception is raised, the `except` block is executed, if not, it isn’t.
- Regardless of an exception being raised or not, the code in the `finally` block will be executed.
The big difference between exception handling in Python and other languages is that in Python using exceptions for flow control is common and normal. In fact, in many cases, you must use exceptions for control-flow. This is where the else
clause comes in.
The optional else
clause, which has to be before the finally
clause (if there is one), is executed if and when control flows off the end of the try
clause. Currently, control “flows off the end” except in the case of an exception or the execution of a return
, continue
, or break
statement. So, for example:
>>> try:
... print("Try: I'll try not to raise an exception.")
... except:
... print("Except: You hopefully won't see me.")
... else:
... print("Else: No exceptions was raised.")
... finally:
... print("Finally: I'm going to run anyway.")
...
Try: I'll try not to raise an exception.
Else: No exceptions was raised.
Finally: I'm going to run anyway.
But, why!?
As mentioned earlier, it is very common to use Python’s try
statement as to control the flow of our program. So, the else
clause is a very neat way of executing some code if an exception isn’t raised.
For instance, one way to check if a file exists is:
try:
f = open('some-file.txt')
except IOError:
print("File doesn't exist :-(")
else:
print("File exists!")
If some-file.txt
exists and opens successfully, then an exception will not be raised and the else
clause will be executed (File exists!
will be printed). Otherwise, the else
clause will not be executed (File doesn’t exist :-(
will be printed).
Also, without the else
clause, the only option to run additional code before finalisation (which is rare) would be the clumsy practice of adding the code to the try
clause. This is clumsy because it risks raising exceptions in code that wasn’t intended to be protected by the try
statement.
In general, in Python, there is probably not a case where you have no choice but to use the else
clause in a try
statement. But, besides allowing you to control the flow of your program without much hassle, it will often make the code more elegant, readable and Pythonic as well.