Raise Exception in Python

Most of the programmers/developers create large programs to solve complex tasks in Python. The code can be of 1000 lines and even more based on the need of the problem. After writing a huge code, imagine running into an unexpected error in the middle and not being able to find where the code is going wrong. These unexpected errors caught at the run time and disturb the program flow are called Exceptions. Although, Exceptions are like villains in this story, there is a need for exceptions too. In Python, we can handle these exceptions using the try-except statements.

Let us take an example. What if the user gives an invalid input like 0 for a divisor? Division with 0 is not possible. By raising an exception, Python tells us to handle the program if the user gives the invalid input. These exceptions are inbuilt in Python. For example, we are writing a code in which the user should not give the input as 5. If given, it raises a bug. No inbuilt exception stops the program from raising an exception if the input is 5. No worries, we can raise our custom exceptions and later handle them the way we want.

Python never leaves the user dissatisfied. There are ways open to trying out different paths to reach a solution. This article will discuss how to create and raise our custom exceptions in Python.

raise Keyword

We add a condition into the inbuilt set of exception conditions. There is a keyword in Python called "raise" to raise our exceptions. We can demand an exception to occur in a specific situation using this keyword.

Syntax:

raise {exception_we_want_to_raise}

We can also print a message by:

raise Exception_name (“message to display”)

Let us take an example:

a = int (input ("Enter a non-zero number: "))
if (a == 0):
    raise Exception ("Not zero please!")

Output:

Enter a number: 0
Traceback (most recent call last):
  File "D:\Programs\Python\untitled0.py", line 10, in <module>
    raise Exception ("Not zero please!")
Exception: Not zero please!

Understanding:

We asked for a non-zero number, but we raised an Exception if the user gave the input as 0.

• We used the Exception class because; it is the superclass for exceptions. We can raise any exception we want.
• We can raise a TypeError in the above case, but generally, a TypeError is raised when the given value's data type does not match its slot. Our situation is not this in the above program.

Raising a TypeError:

a = "Hey"
if (type (a) is not int):
    raise TypeError ("Only int permitted")

Output:

Traceback (most recent call last):
  File "D:\Programs\Python\untitled0.py", line 10, in <module>
    raise TypeError ("Only int permitted")
TypeError: Only int permitted

Understanding:

a is a string with "Hey". But we don't want it to be a string. We need a to be an integer. Hence, we checked the type of a and raised a TypeError if it is not an integer.

Handling the raised exceptions:

Raising an exception alone is not enough to handle an exceptional situation. The program raises the exception and stops there. We need to handle the exception that we raised to get the program going.

#Handling a TypeError:
a = "Hey"
try:
    if (type (a) is not int):
        raise TypeError ("Only int permitted")
except TypeError:
    print ("a must be an integer")

Output:

a must be an integer

• Suppose we raise an exception if the user gives the number 5; if we do not handle it, when 5 is given, the program will raise an exception and stop there, which is not what we want. We need to do something like ask the user again not to give 5 as the input. We need to use the try-except statements to handle the exceptions.

a = int (input ("Enter an integer except 5: "))
try:
    if (a == 5):
        raise Exception ("Not 5!")
except Exception:
    print ("Please don't enter 5")
    a = int (input ("Enter an integer: "))

Output:

Enter an integer except 5: 5
Please don't enter 5


Enter an integer: 4

• Specifying the exception class is not compulsory in the syntax of raise. We can say raise. Using a simple raise without giving the exception name raises the last raised exception again.
• In the above program, we raised an exception if the user gives input as 5. We handled the exception by asking for the input again. We can say raise to raise the same exception if the user gives 5 again:

a = int (input ("Enter an integer except 5: "))
try:
    if (a == 5):
        raise Exception ("Not 5!")
except Exception:
    print ("Please don't enter 5")
    a = int (input ("Enter an integer: "))
    raise

Output:

Enter an integer except 5: 5
Please don't enter 5
Enter an integer: 5
Traceback (most recent call last):
  File "D:\Programs\Python\untitled0.py", line 12, in <module>
    raise Exception ("Not 5!")
Exception: Not 5!

Advantages of using raise:

1. Using raise is most useful to check the given input according to the program's need.
2. When the programmer has to handle a specific situation in the program and wants to do it later, he can raise an exception and handle it with a message to remind him to handle it – like the pass statement.

Summary

• You might have observed that most of the time, you want to raise an exception; there is no certain exception that matches as per needs. Hence, you can use the superclass – Exception.
• What if we name the exception with the name we want? But such exceptions will not be valid as they are not in-built.
• There is still a solution. We can also create our own exceptions in Python. We can specify the exception we created after the raise keyword; it even increases the readability of the code.
• Here is a simple example:

class ValueLessThan100 (Exception):
    pass
a = int (input ("Enter a number greater than 100: "))
try:
    if (a < 100):
        raise ValueLessThan100
except ValueLessThan100:
    print ("The given value is less than 100")
    a = int (input ("Enter an integer greater than 100: "))
    if (a < 100):
        raise

Output:

Enter a number greater than 100: 35
The given value is less than 100


Enter an integer greater than 100: 67
Traceback (most recent call last):
  File "D:\Programs\Python\untitled0.py", line 14, in <module>
    raise ValueLessThan100
ValueLessThan100

Understanding:

In above code, we don't want the input by the user to be less than 100. We created a custom exception, "ValueLessThan100". We took the input from the user. If the user gives 100, we raised the exception, handled it with a message, and asked for another input. Still, if the user gives a number less than 100, we re-raised our exception.

• You can see that the name of the exception is quite enough to understand what went wrong in the program, thus, increasing the readability of the code.