Python Exceptions Handling


Contents

Python contributes in 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:

    Sr.No.

    Exception Name & Description

    1

    Exception

    Base class for all exceptions

    2

    StopIteration

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

    3

    SystemExit

    Raised by the sys.exit() function.

    4

    StandardError

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

    5

    ArithmeticError

    Base class for all errors that occur for numeric calculation.

    6

    OverflowError

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

    7

    FloatingPointError

    Raised when a floating point calculation fails.

    8

    ZeroDivisionError

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

    9

    AssertionError

    Raised in case of failure of the Assert statement.

    10

    AttributeError

    Raised in case of failure of attribute reference or assignment.

    11

    EOFError

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

    12

    ImportError

    Raised when an import statement fails.

    13

    KeyboardInterrupt

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

    14

    LookupError

    Base class for all lookup errors.

    15

    IndexError

    Raised when an index is not found in a sequence.

    16

    KeyError

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

    17

    NameError

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

    18

    UnboundLocalError

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

    19

    EnvironmentError

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

    20

    IOError

    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.

    21

    IOError

    Raised for operating system-related errors.

    22

    SyntaxError

    Raised when there is an error in Python syntax.

    23

    IndentationError

    Raised when indentation is not specified properly.

    24

    SystemError

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

    25

    SystemExit

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

    26

    TypeError

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

    27

    ValueError

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

    28

    RuntimeError

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

    29

    NotImplementedError

    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 upon 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 hold 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.

    Example

    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 display a negative temperature:

    #!/usr/bin/python
    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:

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

    What is 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 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.

    Syntax

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

    try:
       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.
       ......................
    else:
       If there is no exception then execute this block. 
    

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

    • An individual try statement could have manifold except 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-block proceeds if the code in the try: block does not raise an exception.
    • The else-block is a high-quality code placed that never require the try: block's protection.

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

    #!/usr/bin/python
    
    try:
       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"
    else:
       print "Written content in the file successfully"
       fh.close()

    This produces the following result:

    Written content in the file successfully
    

    Example

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

    #!/usr/bin/python
    
    try:
       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"
    else:
       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:

    try:
       You do your operations here;
       ......................
    except:
       If there is any exception, then execute this block.
       ......................
    else:
       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 entire exceptions, yet it fails effort the programmer identify, which is the prime cause of the problem that may occur.

    The except Clause with Multiple Exceptions

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

    try:
       You do your operations here;
       ......................
    except(Exception1[, Exception2[,...ExceptionN]]]):
       If there is any exception from the given exception list, 
       then execute this block.
       ......................
    else:
       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 finally block is a place to put any code created to execute, whereas, try-block raise an exception. The syntax of the try-finally statement is this:

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

    You cannot use else clause along with a finally clause.

    Example

    #!/usr/bin/python
    
    try:
       fh = open("testfile", "w")
       fh.write("This is my test file for exception handling!!")
    finally:
       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
    

    Same example can be written more cleanly as follows:

    #!/usr/bin/python
    
    try:
       fh = open("testfile", "w")
       try:
          fh.write("This is my test file for exception handling!!")
       finally:
          print "Going to close the file"
          fh.close()
    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.

    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 –

    try:
       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.

    Example

    Following is an example for a single exception

    #!/usr/bin/python
    
    # Define a function here.
    def temp_convert(var):
       try:
          return int(var)
       except ValueError, Argument:
          print "The argument does not contain numbers\n", Argument
    
    # Call above function here.
    temp_convert("xyz");

    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.

    Syntax

    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.

    Example

    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 simple string. For example, to capture above exception, we must write the except clause as follows:

    try:
       Business Logic here...
    except "Invalid level!":
       Exception handling here...
    else:
       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 Networkerror.

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

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

    try:
       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.



Navigation
Tutorial
Tutorial
Tutorial