Exception Handling in Python

The cause of an exception is often external to the program itself. For example, an incorrect input, a malfunctioning IO device etc. Because the program abruptly terminates on encountering an exception, it may cause damage to system resources, such as files. Hence, the exceptions should be properly handled so that an abrupt termination of the program is prevented.

Python uses try and except keywords to handle exceptions. Both keywords are followed by indented blocks.

try :
    #statements in try block
except :
    #executed when error in try block

The try: block contains one or more statements which are likely to encounter an exception. If the statements in this block are executed without an exception, the subsequent except: block is skipped.

If the exception does occur, the program flow is transferred to the except: block. The statements in the except: block are meant to handle the cause of the exception appropriately. For example, returning an appropriate error message.

You can specify the type of exception after the except keyword. The subsequent block will be executed only if the specified exception occurs. There may be multiple except clauses with different exception types in a single try block. If the type of exception doesn't match any of the except blocks, it will remain unhandled and the program will terminate.

The rest of the statements after the except block will continue to be executed, regardless if the exception is encountered or not.

The following example will throw an exception when we try to devide an integer by a string.

try:
    a=5
    b='0'
    print(a/b)
except:
    print('Some error occurred.')
print("Out of try except blocks.")

Some error occurred.
Out of try except blocks.

You can mention a specific type of exception in front of the except keyword. The subsequent block will be executed only if the specified exception occurs. There may be multiple except clauses with different exception types in a single try block. If the type of exception doesn't match any of the except blocks, it will remain unhandled and the program will terminate.

try:
  a=5
  b='0'
  print(a+b)
except TypeError:
  print('TypeError Occurred')
except:
  print('Some error occurred.')  
print ("Out of try except blocks")

TypeError Occurred
Out of try except blocks

The default except: block must come after all the except block that catch specific errors; otherwise Python will raise an error.

try:
  a=5
  b='0'
  print(a+b)
except:
  print('Some error occurred.')  #except: before other blocks
except TypeError:
  print('TypeError Occurred')
print ("Out of try except blocks")

File "main.py", line 4
    print(a+b)
    ^
SyntaxError: default 'except:' must be last

As mentioned above, a single try block may have multiple except blocks. The following example uses two except blocks to process two different exception types:

try:
    a=5
    b=0
    print (a/b)
except TypeError:
    print('Unsupported operation')
except ZeroDivisionError:
    print ('Division by zero not allowed')
except:
  print('Some error occurred.')
print ('Out of try except blocks')

Division by zero not allowed
Out of try except blocks

However, if variable b is set to '0', TypeError will be encountered and processed by corresponding except block.

else and finally

In Python, keywords else and finally can also be used along with the try and except clauses. While the except block is executed if the exception occurs inside the try block, the else block gets processed if the try block is found to be exception free.

try:
    #statements in try block
except:
    #executed when error in try block
else:
    #executed if try block is error-free
finally:
    #executed irrespective of exception occured or not

The finally block consists of statements which should be processed regardless of an exception occurring in the try block or not. As a consequence, the error-free try block skips the except clause and enters the finally block before going on to execute the rest of the code. If, however, there's an exception in the try block, the appropriate except block will be processed, and the statements in the finally block will be processed before proceeding to the rest of the code.

The example below accepts two numbers from the user and performs their division. It demonstrates the uses of else and finally blocks.

try:
  x,y = 10, 2
  z=x/y
except ZeroDivisionError:
  print("except ZeroDivisionError block")
  print("Division by 0 not accepted")
except:
  print('Some error occurred.')
else:
  print("Division = ", z)
finally:
  print("Executing finally block")
  x=0
  y=0
print ("Out of try, except, else and finally blocks." )

The first run is a normal case. The out of the else and finally blocks is displayed because the try block is error-free.

Division =  5.0
Executing finally block
Out of try, except, else and finally blocks.

The second run is a case of division by zero, hence, the except block and the finally block are executed, but the else block is not executed.

try:
  x,y = 10, 0
  z=x/y
except ZeroDivisionError:
  print("Cannot devide by zero. Try again")
  print("Division by 0 not accepted")
except:
  print('Some error occurred.')
else:
  print("Division = ", z)
finally:
  print("Executing finally block")
  x=0
  y=0
print ("Out of try, except, else and finally blocks." )

Cannot devide by zero. Try again
Division by 0 not accepted
Executing finally block
Out of try, except, else and finally blocks.

In the third run case, an uncaught exception occurs. The finally block is still executed but the program terminates and does not execute the program after the finally block.

try:
  x,y = 10, "xyz"
  z=x/y
except ZeroDivisionError:
  print("except ZeroDivisionError block")
  print("Division by 0 not accepted")
except:
  print('Error occurred.')
else:
  print("Division = ", z)
finally:
  print("Executing finally block")
  x=0
  y=0
print ("Out of try, except, else and finally blocks." )

Error occurred.
Executing finally block
Out of try, except, else and finally blocks.

Typically the finally clause is the ideal place for cleaning up the operations in a process. For example closing a file irrespective of the errors in read/write operations. This will be dealt with in the next chapter.

Raise an Exception

Python also provides the raise keyword to be used in the context of exception handling. It causes an exception to be generated explicitly. Built-in errors are raised implicitly. However, a built-in or custom exception can be forced during execution.

The following code accepts a number from the user. The try block raises a ValueError exception if the number is outside the allowed range.

try:
  x,y=100,2
  z=x/2
  if z > 10:
    raise ValueError(z)
except ValueError:
  print(z, "is out of allowed range")
else:
  print(z, "is within the allowed range")

50.0 is out of allowed range

Here, the raised exception is a ValueError type. However, you can also raise a custom exception type. Visit Python docs to know more about user defined exceptions.