Exception Handling in Python: Handling Exception Using Try Except

While encountering an error a program of Python gets terminated. The errors are generally problems occurring in a program that stops its execution. The errors may be due to an error in syntax or might be an exception. Whenever an incorrect statement is detected by the parser, there is an occurrence of a syntax error.

However, when the code with the correct syntax generates an error, then it’s known as an exception. Various built-in exceptions are available in python. These are raised with the occurrence of internal events where the normal flow of a program gets changed.

Therefore exceptions may be defined as certain unusual program conditions that result in an interruption of the code and hence the program flow is aborted. 

The execution of a program stops as soon as it encounters an exception. This further stops the code to execute. Hence, exceptions are errors as a result of run-time that are unable to be handled by the python script.

For exception handling in python, the scripting language python provides a solution so that the execution of the code carries on and there aren’t any interruptions. The absence of exception handling stops executing the code that exists after the code that throws an exception.

Several built-in options are available in python that allows the execution of a program without any interruption including the common exceptions. Along with this, there is a provision of python custom exceptions.  For any python program, the common exceptions that can be thrown are:

• ZeroDivisionError: This type of exception results when zero is used to divide a number.
• NameError: Whenever a program fails to find a name be it global or local, this type of exception occurs.
• IndentationError: Incorrect indentation gives rise to the indentationError.
• IOError: Failure of an Input-Output operation results in IOError.
• EOFError: It occurs in the continuous operation of a program  even when the file end is reached.

Check out our data science training to upskill yourself

Understanding Errors and Exceptions in Python

Python is a robust and widely used programming language known for its simplicity and readability. However, no matter how carefully you write your code, errors and exceptions can still occur during program execution. Various factors, such as incorrect input, faulty logic, or unexpected situations, can cause these errors. To ensure that your Python programs handle these errors gracefully and continue running without crashing, Python provides robust exception-handling mechanisms.

Errors and exceptions in Python are integral to any programming language, including. Errors can be categorized into two main types: syntax errors and logical errors. Syntax errors occur when the code violates the language’s syntax rules and prevents the program from running. The Python interpreter typically catches these errors during the parsing phase and must be fixed before the program executes.

On the other hand, exceptions are runtime errors that occur during program execution. Exceptions are often caused by unforeseen circumstances, such as invalid input, division by zero, or accessing an out-of-bounds index. When an exception occurs, the program halts its normal execution and raises an exception object, which the programmer can then catch and handle. Python provides a comprehensive set of built-in exceptions to handle various errors effectively.

Raising an exception

For throwing an exception under certain conditions the raise is used.
The execution of the program is halted and the associated exception is displayed on the screen. The display of the exceptions lets the users know what might be the underlying problem.

In python through the use of the raise clause, we can raise an exception. The application is useful in cases when the program needs to be stopped by raising an exception. 

For example: Supposedly a program needs around 1GB of memory for its execution and it tries occupying 1 GB, in that case, to stop executing the program an exception can be thrown.

Syntax for raising an exception:

Exception_class,<value>

Therefore, 

• ‘raise’ is used for raising an exception in a program.
• A value can be provided to an exception which can be provided to the parenthesis.
• Accessing the value can be done with the keyword ”as”. The value given to the exception can be stored in the reference variable denoted by “e”.
• For specifying an exception type, the value can be passed to an exception.

AssertionError
An assertion can be made in python instead of letting the program crash. An assertion is made that a specific condition is met by the program. The program will continue running if the condition is true. Else an AssertionError exception is thrown by the program when the condition turns out to be false.

Exception Handling in Python

Exception handling is handling and recovering from exceptions during program execution. By implementing appropriate exception-handling techniques, you can ensure that your program doesn’t crash abruptly and provides meaningful error messages or performs alternative actions when exceptions occur. Python offers a try-except block, the primary construct for exception handling.

The try-except block allows you to enclose a section of code that might raise an exception within the try block. If an exception happens within the try block, the program flow immediately jumps to the except block that matches the exception type. The except block contains the code to handle the exception gracefully, whether displaying an error message, logging the exception, or performing any necessary cleanup actions.

Let’s illustrate exception handling in Python with example:

    dividend = int(input("Enter the dividend: "))
    divisor = int(input("Enter the divisor: "))
    result = dividend / divisor
    print("Result: ", result)
except ValueError:
    print("Invalid input. Please enter a valid integer.")
except ZeroDivisionError:
    print("Cannot divide by zero. Please enter a non-zero divisor.")
except exception as e:
    print("An error occurred:", str(e))

In the above example of exception handling in Python with example, we’re attempting to divide two numbers provided by the user. The try block has the code that could potentially raise exceptions. If the user enters invalid input, such as non-numeric characters, a ValueError exception will be raised and caught by the respective except block, which displays an error message.

Similarly, if the user enters zero as the divisor, a ZeroDivisionError exception is raised and handled accordingly. The final except block catches any other exceptions that may occur and displays a generic error message along with the specific exception details.

Handling exceptions through the try and except block

Exceptions thrown in python are caught and then handled by the try and except blocks in python.  The code within the try block is executed normally as the program’s part.  The other block includes statements that are executed in response to the exceptions thrown by the program in the try block.

The program throws an exception whenever it encounters an error in a syntactically correct code. If the exceptions thrown are not handled properly there will be a crash in the programs. In such scenarios, the except block determines the response of the program to that exception.

The application of the try and except clause will be best understood through the following example taken from the mentioned source.

In this case, whenever there is an occurrence of an exception, the program will continue running and will inform the user that the program was not successful rather than giving a blank output.

Checkout: Python Project Ideas & Topics

The program showed the error type that was thrown through the call of the function. However, the error thrown by the function can be caught to get an idea of what actually went wrong.

Running the code in a windows machine will generate the following

The message displayed first indicates an AssertionError  through which the user is informed that the function can be executed only on a system of Linux operating system. The second message further gives the information of which function was not able to get executed.
Non existence if the file.log will generate an output with the message “Could not open file.log”. 

Explore our Data Science Online Certifications

The program will still continue running as it is a message that relays the information to the user. A lot of built-in exceptions are available in Python docs. One exception as described is shown below.

The non-existence of the file.log in this case will generate the following output.

Various exceptions can be caught through the use of more function calls in the try clause. However, on detecting an exception, the try clause statements will stop.

Top Data Science Skills You Should Learn

The else clause 

Use of the else clause of statements can aid in instructing the program for executing a block of statements only when there are no exceptions. 

The else clause got executed only because there were no exceptions. If the code contains exceptions, then the following will result.

upGrad’s Exclusive Data Science Webinar for you –

Watch our Webinar on The Future of Consumer Data in an Open Data Economy

Python custom exceptions

Python has a number of built-in exceptions that throw an error whenever there is something wrong in the program. However, the user needs to create some customized exceptions in cases where his purpose is to be served.

A new class can be created for defining the custom exceptions. Either directly or indirectly, these classes have to be derived from the class of built-in exceptions.

The user-defined class CustomError is created that is inherited from the class Exception. Similar to the other exceptions, these exceptions too are raised through the use of ‘raise’ with an error message that is optional.

The user-defined exceptions should be placed in a separate file whenever there is a development of a large python program. It is generally a good practice to do this and is followed by most of the standard modules where the exceptions are defined separately as errors.py or exceptions.py.

The python custom exceptions are simple and as the normal classes implement everything they too follow the same. 

Syntax and Examples

Let us consider two variables which are a, and b. The input to the variables is taken from the user and the division of the numbers is performed. Now, if the denominator entered by the user is a zero.  

For handling these exceptions, the try-except blocks can be added to the program. For any type of code that leads to a suspicion of throwing exceptions. It should be placed in the try block of statements. 

Read our popular Data Science Articles

Syntax of a try block

try:     
#code        
except Exception1:    
 #code        
except Exception2:    
 #code        
#code    

It shows the use of try-except statements where the code is placed in the try block and gets executed when there are no exceptions in the code. 

Syntax of else statement with try-except

try
#try statements
Except Exception1
#code
Else
#execution of code when there is no exception

A few important points:

• The exception is not to be specified through a statement of exception in python.
• Multiple exceptions can be declared in a code through the use of a try block as there can be many statements inside a try block that can throw exceptions of different types.
•  An else block can be specified with a try block which gets executed when there are no exceptions thrown by the try block.
• The else block should contain statements that are not responsible for throwing exceptions.

Also, Check out all Python tutorial concepts Explained with Examples.

Conclusion 

In this article, we briefly discussed the concept of exception handling in python with some examples. Along with the built-in exceptions, the python custom exceptions are also defined briefly. Now, you can know the importance of exceptions and the handling of exceptions in python.

If you are interested in learning more about the python language and its implementation in data science, you can check out the following course of upGrad “Executive PG Programme in Data Science”.

The online course is designed for all entry-level professionals who fall within the age group of 21 to 45 years of age. With over 20+ live sessions and practical knowledge of 14+ tools and programming languages, the course will guide you towards perfectness. Any queries could be messaged. Our team will help you.