Python Exceptions Handling


Python contributes two vital features for handling any unexpected error in Python language programming. It facilitates users to add debugging abilities in them-

    • Exception Handling - The factor is mentioned in the provided tutorial. Here is a standard list of Exceptions easy to get to in Python: Standard Exceptions.
    • Assertions - the assertions have been covered in Assertions in Python tutorial.

List of Standard Exceptions:


Exception Name & Description



Base class for all exceptions



Raised when the next() method of an iterator does not point to any object.



Raised by the sys.exit() function.



Base class for all built-in exceptions except StopIteration and SystemExit.



Base class for all errors that occur for numeric calculation.



Raised when a calculation exceeds the maximum limit for a numeric type.



Raised when a floating-point calculation fails.



Raised when division or modulo by zero takes place for all numeric types.



Raised in case of failure of the Assert statement.



Raised in case of failure of attribute reference or assignment.



Raised when there is no input from either the raw_input() or input() function and the end of file is reached.



Raised when an import statement fails.



Raised when the user interrupts program execution, usually by pressing Ctrl+c.



Base class for all lookup errors.



Raised when an index is not found in a sequence.



Raised when the specified key is not found in the dictionary.



Raised when an identifier is not found in the local or global namespace.



Raised when trying to access a local variable in a function or method but no value has been assigned to it.



Base class for all exceptions that occur outside the Python environment.



Raised when an input/ output operation fails, such as the print statement or the open() function when trying to open a file that does not exist.



Raised for operating system-related errors.



Raised when there is an error in Python syntax.



Raised when indentation is not specified properly.



Raised when the interpreter finds an internal problem, but when this error is encountered the Python interpreter does not exist.



Raised when Python interpreter is quit by using the sys.exit() function. If not handled in the code, causes the interpreter to exit.



Raised when an operation or function is attempted that is invalid for the specified data type.



Raised when the built-in function for a data type has the valid type of arguments, but the arguments have invalid values specified.



Raised when a generated error does not fall into any category.



Raised when an abstract method that needs to be implemented in an inherited class is not actually implemented.

Assertions in Python

An assertion is sanity verification that users can switch on or switch off when users have accomplished testing of the program.

The easiest method to believe of an assertion is to prefer it to a raise-if statement (or to be more precise a raise-if-not statement). An expression is tested, and if the consequence comes up false, an exception is lifted.

Assertions are performed by the assert statement, the latest keyword to Python any version, launched in version 1.5.

Programmers frequently place assertions at beginning of a function to verify for applicable input, and after a function call to confirm for convincing output.

The assert Statement

When it comes to an assert statement, Python appraises the complementary expression, which is expectantly genuine. If the expression is false, Python hoists an AssertionError exception.

The syntax for assert is :

Use the web-based JavaScript cleaner to organize and beautify scripts.

assert Expression[, Arguments]

If the assertion fails, Python utilizes ArgumentExpression as the argument for the AssertionError. AssertionError exceptions can be beheld and handled such as any other exception using the try-except statement, however, if not handled, they would terminate the agenda and construct a traceback.


Here is a function that changes a temperature from degrees Kelvin to degrees Fahrenheit. Since zero degrees Kelvin is as cold as it projects, the function bails out if it displays a negative temperature:

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32
print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

When the above code is executed, it produces the following result:

Traceback (most recent call last):
File "test.py", line 9, in 
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

What is an Exception?

An exception is an occasion, which creates throughout the implementation of a program that breaks off the average run of the program's orders. Usually, when a Python script finds a state of affairs, it neither cope with nor raises an exception. An objection is a Python programming language object that depicts a blunder.

While a Python script raises an exception, it has to either manage the exception right away or else it terminates and quits.

Managing an exception

If users have a number of suspicious codes that strength raises an exception, users can cause to be a program by insertion the suspicious code in a try: block. Following the try: block incorporates except statement, adhered by a block of code, which handles the problem as smartly as probable.


Here is the simple syntax of try....except...else blocks

   You do your operations here;
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   If there is no exception then execute this block.  

Here are some of the necessary points related to the aforementioned syntax-

      • An individual try statement could have manifold except for statements. This is versatile when the try block comprises statements that might throw a variety of types of exceptions.
      • Users can additionally provide a generic apart from clause, which handles any exception.
      • After except clause(s), users could contain an else-clause. The code in the else blocks proceeds if the code in the try: block does not raise an exception.
      • The else-block is a high-quality code placed that never requires the try: block's protection.


This example opens a file, writes content in the file, and opens out swiftly due to no issues found


   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
   print "Written content in the file successfully"

This produces the following result:

Written content in the file successfully


This example tries to open a file where you do not have write permission, so it raises an exception


   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print "Error: can\'t find file or read data"
   print "Written content in the file successfully"

This produces the following result:

Error: can't find file or read data

The except Clause with No Exceptions

You can also use the except statement with no exceptions defined as follows:

   You do your operations here;
   If there is any exception, then execute this block.
   If there is no exception then execute this block.  

This type of a try-except statement holds entire exceptions that exist. Implementing such kind of try-except statement is never thought a high-quality programming practice. However, the command is able to hold on to entire exceptions, yet it fails the effort the programmer identify, which is the prime cause of the problem that may occur.

The except Clause with Multiple Exceptions

You can also used the same except statement to handle multiple exceptions as follows:

   You do your operations here;
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   If there is no exception then execute this block.

The try-finally Clause

Using a finally: block along with a try: block delivers try-finally statement. Here, the final block is a place to put any code created to execute, whereas, try-block raises an exception. The syntax of the try-finally statement is this:

   You do your operations here;
   Due to any exception, this may be skipped.
   This would always be executed.

You cannot use else clause along with a final clause.



   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
   print "Error: can\'t find file or read data"

If you do not have permission to open the file in writing mode, then this will produce the following result:

Error: can't find file or read data

The same example can be written more cleanly as follows:


   fh = open("testfile", "w")
      fh.write("This is my test file for exception handling!!")
      print "Going to close the file"
except IOError:
   print "Error: can\'t find file or read data"

With the exception executed in the try block, the execution instantly passes to the finally block. After every statement provided in the finally block are always executed. The executed exception rises to handle in the except statements if there is next higher layer of the try-except statement.

The argument of an Exception

An exception can have an argument, which is a value that gives additional information about the problem. The contents of the argument vary by exception. You capture an exception's argument by supplying a variable in the except clause as follows-

   You do your operations here;
except ExceptionType, Argument:
   You can print value of Argument here...

If users provide the code to manage an individual exception, then users could have a variable go after the forename of the exception in except statement. If users are trapping multiple exceptions, then they could have a variable go after the Tuple of the exception.

These variables receive the value of the exception more often than not compromising the cause of the exception. The variable could receive an individual value or multiple values in the form of a Tuple. This Tuple more often than have incorporated the error string, the error number, and an error location.


Following is an example of a single exception


# Define a function here.
def temp_convert(var):
      return int(var)
   except ValueError, Argument:
      print "The argument does not contain numbers\n", Argument

# Call above function here.

This produces the following result:

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Raising an Exceptions

You can raise exceptions in several ways by using the raise statement. The general syntax for the raise statement is as follows.


raise [Exception [, args [, traceback]]]

Here, Exception is the type of exception (for example, NameError) and argument is a value for the exception argument. The argument is optional; if not supplied, the exception argument is None.

The final argument, traceback, is also optional (and rarely used in practice), and if present, is the traceback object used for the exception.


An exception can be a string, a class or an object. Most of the exceptions that the Python core raises are classes, with an argument that is an instance of the class. Defining new exceptions is quite easy and can be done as follows

def functionName( level ):
   if level < 1:
      raise "Invalid level!", level
      # The code below to this would not be executed
      # if we raise the exception

Note: In order to catch an exception, an "except" clause must refer to the same exception thrown either class object or a simple string. For example, to capture the above exception, we must write the except clause as follows:

   Business Logic here...
except "Invalid level!":
   Exception handling here...
   Rest of the code here...

User-Defined Exceptions

Python also allows you to create your own exceptions by deriving classes from the standard built-in exceptions.

Here is an example related to RuntimeError. Here, a class is created that is subclassed from RuntimeError. This is useful when you need to display more specific information when an exception is caught.

In the try block, the user-defined exception is raised and caught in the except block. The variable e is used to create an instance of the class Network error.

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

So once you defined the above class, you can raise the exception as follows:

   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

Here at Intellinuts, we have created a complete Python tutorial for Beginners to get started in Python.