Exception Handling

This page is under construction. Please come back later.

Many functions take in arguments, do a computation and return a result without any diffuculties. But some functions may run into problems that need to be reported to the calling code. Problems can be found in the arguments being passed, with system resources that are not available or with computations that just can't be performed. Returning an error code through the formal return value of a function is one technique but it requires the calling code to check the result of a function to see if the error code was returned. Often this step is omitted resulting in bad values being propogated through the code. A better approach is to have the function throw an exception. An exception is just an object that is returned through the alternate exceptional return mechanism instead of the normal return mechanism. In the following example the stoi() and stof() functions could fail if the string passed can't be converted to a number. In the case of stoi() this function returns numbers across the whole range of integers so there is no value that can be returned to indicate an error that is not also a valid integer. This is why these two functions return a value if they can and if they can not, they throw an exception. Because the code below doesn't check for execptions being thrown, it will simply quit and print an error message detailing the exception thrown if bad input is passed to either of the two functions.

Exceptions1.py

#!/usr/bin/env python3;
import Utils
import sys

# Begin Main
i = int(sys.argv[1])
d = float(sys.argv[2])
print("i + d = {0:f}".format(i + d))

In the example below we add exception handling code around each of the two functions that can throw. This is done useing a try/except construct. The try block wraps the code that might throw an exception. Following the try block is a except block that contains the error handling code that is only executed if an exception is thrown in the preceding try block. When an exception is thrown, the try block is terminated immediately and control passes to the except block. If no exception is thrown, all the code in the try block is executed and the except block is skipped. The example below illustrates what will happen with good input and some bad input.

Exceptions2.py

#!/usr/bin/env python3;
import Utils
import sys

# Begin Main
i = 0
d = 0
try :
	i = int(sys.argv[1])
except Exception as ex :
	print("Can't convert to integer!")
	sys.exit(1)
try :
	d = float(sys.argv[2])
except Exception as ex :
	print("Can't convert to floating point!")
	sys.exit(1)
print("i + d = {0:f}".format(i + d))

As this code illustrates, exception handling allows use to possibly recover from an error or at a minimum, present a more meaningful error message to the user and then terminate the program in an orderly fashion.

The example above illustrates one way to deal with exceptions, namely providing a try/except construct to wrap each and every function that might throw. While this a very fine-grained approach that gives us lots of control, it can become tedious if many functions that can throw are being used. Another approach is presented below whereby all the core logic of our main code is wrapped in a single try/except. If any of the functions in main throw an exception it will cause control flow to immediately jump into the except handler. This approach requires less exception handling code but sometimes prevents us from knowing exactly which function had a problem that required it to throw an exception.

Exceptions3.py

#!/usr/bin/env python3;
import Utils
import sys

# Begin Main
i = 0
d = 0
try :
	i = int(sys.argv[1])
	d = float(sys.argv[2])
	print("i + d = {0:f}".format(i + d))
except Exception as ex :
	print("Can't convert command line argument!")

Exceptions4.py

#!/usr/bin/env python3;
import Utils
import sys

# Begin Main
i = 0
d = 0
try :
	i = int(sys.argv[1])
	d = float(sys.argv[2])
	print("i + d = {0:f}".format(i + d))
except ValueError as ex :
	print("Can't convert command line argument!")
except Exception as ex :
	print("Don't know what went wrong!")

Exceptions5.py

#!/usr/bin/env python3;
import Utils
import sys

# Begin Main
i = 0
d = 0
try :
	i = int(sys.argv[1])
	d = float(sys.argv[2])
	print("i + d = {0:f}".format(i + d))
except ValueError as ex :
	print("Can't convert command line argument!")
except Exception as ex :
	print("Don't know what went wrong!")
finally :
	print("This statement always executes.")

Questions

• {{Who's on first?}}
• {{Who's on second?}}
• {{Who's on third?}}

Projects

More ★'s indicate higher difficulty level.

References

• [[Python Language Reference]]
• [[Python Standard Library]]
• [[Python at TutorialsPoint]]