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:

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.

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 displays 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 
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.

Syntax

Here is the 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 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.

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

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

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 final 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

The 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.

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-

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 of 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 a simple string. For example, to capture the 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 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:

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.