We are very well aware with the importance of programming languages. They are basis for all sorts of Digital and technological advancements we have made.
Hence, since the dawn of the information age, programmers are looking for languages that can provide them variety of features.Guido von Rossum, the creator of the Python, was such programmer. He wanted to have a language that can provide all the features he wanted, for instance Scripting language, High level data type, etc.
Python is a language that is good for projects that require quick developments. It is
general purpose high level language and can be used for variety of programming problems.
Python just like other programming languages provides the method of detecting any errors. However, Python requires the exceptions (errors) to be handled at first instance before the successful execution of the program.
It is quite reasonable that practical applications of the programs may contain aspects that cannot be processed effectively by the programming language. Hence, error handling is an important and useful part of programming.
For brushing up our error handling skills, we will take a look at Exception handling. Here, in this article, we will discuss the major components of Python exception handling. To make the process easier we will first take a look at major aspects of exception handling in Python.
What are exceptions in Python?
Exception in python allows the user to run a program if any problems occur using conditions in except command. Python works as per the instructions of the program. Whenever there are certain aspects which Python does not understand, it shows an exception, which means in the case of Python, the exceptions are errors.
Python ceases the action whenever it encounters any exception. It only completes the execution after the exceptions are handled. Here is an example of exception handling.
Syntax for try except else
Try: Print A. Except exception If A is exception, then execute this block. Else If there is no exception, then execute this block.
This syntax represents, to print A if no exception is present. Otherwise follow the instruction in exception statement. The program specifies certain conditions in case of encountering exceptions.
More than one exceptions can be used in any program.
Else-block can be used after the except clause, if the block in try: does not raises any exception.
Else-block can be used for the code that does not require try: block’s protection.
Generic clause can be provided to handle any exception.
>>> while True print('Hello world') File "
", line 1 while True print('Hello world') ^ SyntaxError: invalid syntax
Here, invalid syntax represent a missing colon before print command, this program cannot be executed due to syntax error.
Why use Exceptions?
Exception can be helpful in case you know a code which can produce error in the program. You can put that code under exception and run an error free syntax to execute your program. This helps in preventing the error from any block which is capable of producing errors. Since exception can be fatal error, one should use exception syntax to avoid the hurdles.
Python itself contains a number of different exceptions. The reasons can vary as per the exception.
Here, we are listing some of the most common exceptions.
These errors are some of the most common ones and are required to be used, in case any sort of exceptions are required to be used.
Python also has assertion feature which can be used for raising exceptions. This feature tests an expression, Python tests it. If the result comes up false then it raises an exception. The assert statement is used for assertion. Assert feature improves the productivity of the exceptions in Python.
However for now, we will just focus upon raising exceptions with the use of raise statement.
Catching Exceptions in Python
Critical block of code which is susceptible to raise exception is placed inside the try clause and the code which handles exception is written with in except clause. If we want any particular or specific exception using- “try” clause would be helpful as we can mention several exceptions under one command.
Raising an exception is beneficial. It helps in obstructing the flow of program and returning the exception until it is handled. Raise statement can be used to raise an statement.
Example of a pseudo code:
try: # do something pass except ValueError: # handle ValueError exception pass except (TypeError, ZeroDivisionError): # handle multiple exceptions # TypeError and ZeroDivisionError pass except: # handle all other exceptions pass
Handling an exception (Syntax & example)
To handle an exception in python, try command is used. And there are certain instruction to use it,
>>> while True: ... try: ... x = int(input("Please enter a number: ")) ... break ... except ValueError: ... print("Oops! That was no valid number. Try again...") ...
Here is another example:
try: num1 = 7 num2 = 0 print (num1 / num2) print(“Done calculation”) except ZeroDivisonError: print(“Infinity”)
The code signifies another example of handling the exception. Here the exception is ZeroDivisionError.
The except Clause with No Exceptions:
Though it is not considered like a good practice, but yet if it has to be done, the syntax will be
print 'foo'+'qux'+ 7 except: print' There is error' You get the output There is error
This type of coding is not usually preferred by programmers because it is not considered as a good coding practice. The except clause is mainly important in case of exceptions. The program has to be given certain exceptions for the smooth execution of the code. It is the main function of the except clause.
The python program containing except clause with no exception is susceptible to errors which can break the flow of the execution of the program. It is a safe practice to recognize any block susceptible to exceptions and using except clause in the case.
Here is another example
word = “python” print(word / 0) except: print(“An error occurred”)
As you can see in the above code, there are no exceptions whatsoever. Moreover the function described in the above code is incorrect. Hence, as per the instructions, we got the following output.
An error occured
The except Clause with Multiple Exceptions:
For multiple exceptions, Python interpreter finds a matching exception, then it will execute the code written under except clause.
import sys try: d = 8 d = d + '5' except(TypeError, SyntaxError)as e: print sys.exc_info()
We get output as shown
, TypeError("unsupported operand type(s) for +: 'int' and 'str'",), )
The usage of multiple exceptions is a very handy process for the programmers. Since, the real world execution requires some aspects which can be in deviation with analytical aspect, the exceptions are handy to use.
Python being particularly used for the quick development projects, prevents exceptions while saving the errors at the same time.
Here is another example with multiple exceptions.
variable = 8 print(variable + “hello”) print(variable / 4) except ZeroDivisonError: print(“Divided by zero”) except (ValueError,TypeError): print(“Error occurred”)
Code given above shows examples of multiple exceptions. The types of error in this program have been excepted(Except here means that the invalid operations that we want to execute are skipped and final message is printed that we want to get printed) and result can be seen below. Since the variable 10 cannot be added to the text ‘hello’ it is quite obvious to have the exceptions, in the case.
>>> Error occurred >>>
The result as expected is “Error occurred”.
The try-finally Clause:
There are certain guidelines using this command, either define an “except” or a “finally” clause with every try block. Also else and finally clauses cannot be used together. Finally clause is particularly useful when the programmer is aware with the outcome of the program.
Generally, it is seen that the else clause is helpful for the programmers with not much expertise in the programming. But when it comes to error correction and termination, this clause is particularly helpful.
try: foo = open ( 'test.txt', 'w' ) foo.write ( "It's a test file to verify try-finally in exception handling!!") print 'try block executed' finally: foo.close () print 'finally block executed'
try block executed finally block executed
Another example can be like
try: f = open("test.txt",encoding = 'utf-8') # perform file operations finally: f.close()
“Finally” is a clause to ensure any code to run without any consequences. Final statement is always to be used at the bottom of ‘try’ or ‘except’ statement. The code within a final statement always runs after the code has been executed, within try po even in ‘except’ blocks.
One more example will make it clearer.
print(“Hello”) print(1/0) except ZeroDivisonError: print(“Divided by zero”) finally: print(“This is going to run anyway”)
As this program makes it clear that the statement “The program is going to run anyway” which is under the “finally” clause is always executed not depending upon the outcome of the code.
Hello Divided by Zero This is going to run anyway
This output shows exactly the same thing.
Argument of an Exception (With example)
Arguments provide a useful way of analyzing exceptions with the interactive environment of Python. If the programmer is having a number of arguments which are to be used in the program, then the programmer can help in more effective results with ‘except’ clause. Here:
def print_sum_twice(a,b): print(a + b) print(a + b) print_sum_twice(4,5)
In this program, the program has instructed the python print the sum twice. There are two conditions that have been specified in the code. Please note that the arguments are enclosed in the parenthesis.
>>> 9 9 >>>
By raising a keyword forcefully we can raise an exception, its an alternative and manual method of raising an exception like exceptions are raised by Python itself.
We can also optionally pass in value to the exception to clarify why that exception was raised. Raising an exception or throwing it is a manual process and it quite helpful when the programmer is well aware with the potential exceptions.
Manual exceptions increase the affectivity in the execution of the program. The manual exceptions save Python from encountering any exceptions itself. Hence, smoothing the execution of the program.
If you want to understand the exception specifically, here is an example.
If you are a programmer and you are well aware with the program you are dealing with, has something that the Python might just not be able to understand. In this case you will like flag that block of code because you understand the significance of that code, so that you can exploit the Python’s capability of using it for quick project development and then deal with that block later.
>>> raise KeyboardInterrupt Traceback (most recent call last): ... KeyboardInterrupt >>> raise MemoryError("This is an argument") Traceback (most recent call last): ... MemoryError: This is an argument >>> try: ... a = int(input("Enter a positive integer: ")) ... if a <= 0: ... raise ValueError("That is not a positive number!") ... except ValueError as ve: ... print(ve) ... Enter a positive integer: -2 That is not a positive number!
Exception classes only function as any regular class. However some simplicity is kept in classes to provide a few attributes improving the efficiency of the exception handling in Python. These attributes can then further be used for extraction by handlers in case of the exceptions.
During the creation of any module it is an optimal process to have a base class for exceptions which are defined particularly by that module. Subclasses can be used for creating error conditions in case of any specific exception.
Python itself offers a variety of exceptions that can be used during the programming by programmers. However, the python also offers also offers full freedom to create any manual exceptions.These exceptions increase the extent of productivity in Python.
class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message
Most exceptions are defined with names that end in “Error”, similar to the naming of the standard exceptions. Standard modules offer their own exceptions for defining any specific error for functions they define.
This is it what we have for ‘Basics of Exception Handling in Python’. If you have any suggestions that we can add in this article to make it more easier for beginners, please do share with us in the comment box.
Free Demo for Corporate & Online Trainings.