Exception Handling in Python Part 2
Exception Handling in Python
Example:
try:
linux_interaction()
except AssertionError
as error:
print(error)
else:
try:
with open('file.log') as file:
read_data = file.read()
except FileNotFoundError as fnf_error:
print(fnf_error)
finally:
print('Cleaning up, irrespective of any
exceptions.')
Summing Up
After seeing the difference between
syntax errors and exceptions, you learned about various ways to raise, catch,
and handle exceptions in Python. In this article, you saw the following
options:
raiseallows you to throw an exception at any time.assertenables you to verify if a certain condition is met and throw an exception if it isn’t.- In the
tryclause, all statements are executed until an exception is encountered. exceptis used to catch and handle the exception(s) that are encountered in the try clause.elselets you code sections that should run only when no exceptions are encountered in the try clause.finallyenables you to execute sections of code that should always run, with or without any previously encountered exceptions.
In Python, users can define such exceptions by
creating a new class. This exception class has to be derived, either directly
or indirectly, from
Exception class. Most of the built-in exceptions are also derived
from this class.
class CustomError(Exception):
pass
Here, we have created a user-defined exception called CustomError which is derived from
the Exception class. This new
exception can be raised, like other exceptions, using the raisestatement with an optional error
message.
When we are developing a large Python program, it is a good
practice to place all the user-defined exceptions that our program raises in a
separate file. Many standard modules do this. They define their exceptions
separately as exceptions.py or errors.py (generally but not always).
Example: User-Defined Exception in
Python
In this example, we will illustrate how
user-defined exceptions can be used in a program to raise and catch errors.
This program will ask the user to enter
a number until they guess a stored number correctly. To help them figure it
out, hint is provided whether their guess is greater than or less than the
stored number.
# define Python user-defined exceptions
class Error(Exception):
"""Base class for other
exceptions"""
pass
class ValueTooSmallError(Error):
"""Raised when the input value
is too small"""
pass
class ValueTooLargeError(Error):
"""Raised when the input value
is too large"""
pass
# our main program
# user guesses a number until he/she gets it right
# you need to guess this number
number = 10
while True:
try:
i_num = int(input("Enter a number:
"))
if i_num < number:
raise ValueTooSmallError
elif i_num > number:
raise ValueTooLargeError
break
except ValueTooSmallError:
print("This value is too
small, try again!")
print()
except ValueTooLargeError:
print("This value is too
large, try again!")
print()
print("Congratulations! You guessed it
correctly.")
Here is a sample run of this program.
Enter a number: 12
This value is too large, try again!
Enter a number: 0
This value is too small, try again!
Enter a number: 8
This value is too small, try again!
Enter a number: 10
Congratulations! You guessed it correctly.
Here, we have defined a base class called Error.
The other two exceptions (ValueTooSmallError and ValueTooLargeError) that are actually raised
by our program are derived from this class. This is the standard way to define
user-defined exceptions in Python programming, but you are not limited to this
way only.
Comments
Post a Comment