Python Custom Exception: A Guide to User-Defined Errors

Have you ever encountered a situation where you wished Python’s built-in exceptions were just not enough to handle your specific needs? Fear not, for Python empowers you with the ability to create your very own custom exceptions! In this blog, we’ll embark on a journey to learn Python custom exception.

Read the previous blog Python Multiple Exception Handling to understand Python Custom Exception or User-defined Exceptions better.

Before diving into the creation of User-defined exception in Python, let’s first get our basics right.

What are Custom Exceptions in Python?

A custom exception is a user-defined exception that is created by the programmer to handle specific error scenarios in a program.

Python allows you to create your own custom exceptions by subclassing the built-in Exception class or any of its subclasses.

When a custom exception is raised, it behaves like any other exception in Python, triggering an error message and terminating the program if it is not handled properly.

Why Use Custom Exceptions?

The main advantage of using custom exceptions is that they make your code more readable, maintainable, and reusable.

By defining your own exceptions, you can create more specific and descriptive error messages that help users and developers to understand the root cause of the problem and take corrective actions.

Custom exceptions also help to modularize your code and promote code reuse across different projects.

How to Create Custom Exception in Python?

Creating a custom exception in Python is straightforward. You need to define a new class that inherits from the built-in Exception class or one of its subclasses.

User-Defined Exception in Python

To define a custom exception, we first need to create a new class with a descriptive name that represents the error we are trying to handle.

It’s a good practice to include the word “Error” at the end of the class name to make it clear that this is an exception.

For example, if we are creating a custom exception to handle a database connection error, we can define a new class called DatabaseConnectionError:

class DatabaseConnectionError(Exception):
    pass

In the above example, we have defined a new class called DatabaseConnectionError that inherits from the base Exception class.

We have also included a pass statement inside the class definition, which indicates that we don’t want to add any new functionality to the class. We are only interested in using it to raise and catch exceptions.

Here is an another example of a custom exception that represents a division by zero error:

class DivisionByZeroError(Exception):
    pass

In this example, we define a new class called DivisionByZeroError that inherits from the built-in Exception class.

Python Custom Exception Arguments

Custom exceptions in Python can take arguments, which provide additional information about the error that occurred. This information can be useful in debugging the application and identifying the root cause of the error.

To define a custom exception with arguments, we need to override the init method of the base Exception class. The init method is called when the exception is raised and allows us to set the values of the instance variables.

class CustomException(Exception):
    def __init__(self, message, error_code):
        self.message = message
        self.error_code = error_code

In the above example, we have defined a custom exception called CustomException that takes two arguments: message and error_code. The init method sets the values of the instance variables message and error_code.

Using custom exceptions with arguments can provide more context and information about the error that occurred, which can be useful in debugging and fixing the issue.

Raise Custom Exception in Python

Once you have defined your custom exception, you can use it in your code to handle specific error scenarios. To raise a custom exception, you simply need to create an instance of the exception class and raise it using the raise keyword.

We can raise the custom exception with arguments using the following code:

raise CustomException("Error occurred", 500)

In the above code, we have raised the custom exception CustomException with the message Error occurred and the error code 500.

Here is an another example of how to raise the DivisionByZeroError exception when a division by zero occurs:

def divide(a, b):
    if b == 0:
        raise DivisionByZeroError("Cannot divide by zero")
    return a / b

result = divide(10, 2)
print(result)  # Output: 5.0

result = divide(10, 0)
print(result)  # Output: DivisionByZeroError: Cannot divide by zero

In this example, we define a function called divide that takes two arguments a and b and returns the result of dividing a by b.

If b is equal to zero, we raise the DivisionByZeroError exception with a descriptive error message. We then call the divide function twice with different arguments and print the results.

Handle Custom Exception in Python

Handling custom exceptions in Python is as crucial as defining them. When we raise a custom exception, it is necessary to handle it to provide a better experience to the user.

Try Except Block

The try-except block is a powerful feature of Python that allows us to catch and handle exceptions. We can use it to catch and handle custom exceptions as well.

class CustomException(Exception):
    pass

try:
    raise CustomException("This is a custom exception")
except CustomException as e:
    print("Caught an exception:", e)

In the above example, we raised the exception using the raise statement. Finally, we used the try-except block to catch the exception and print a message.

Try Except Else Block

The try-except block can also have an else block. The code inside the else block is executed only if the try block does not raise any exceptions.

class CustomException(Exception):
    pass

try:
    print("No exception raised")
except CustomException as e:
    print("Caught an exception:", e)
else:
    print("No exception caught")

In the above example, we have used the try-except-else block to catch the exception. Since there is no raise statement in the try block, the code inside the else block is executed.

Try Except Finally Block

We can also use the finally block in the try-except block. The code inside the finally block is executed regardless of whether an exception is raised or not.

class CustomException(Exception):
    pass

try:
    raise CustomException("This is a custom exception")
except CustomException as e:
    print("Caught an exception:", e)
finally:
    print("This code is executed regardless of whether an exception is raised or not")

In the above example, we have used the “try-except-finally” block to catch the exception. The code inside the “finally” block is executed regardless of whether an exception is raised or not.

Exception Chaining

It is also possible to catch multiple exceptions using the try-except block.

class CustomException(Exception):
    pass

try:
    raise CustomException("This is a custom exception")
except CustomException as e:
    print("Caught a custom exception:", e)
except Exception as e:
    print("Caught an exception:", e)

In the above example, the first except block catches the custom exception, while the second except block catches all other exceptions.

Learn how to create an iterator and range over it using Python Generator.

Customize Python Custom Exception Class

you must have thought why we just put the pass statement in the custom exception class. Can’t we change or override the in-built exception class?

The answer is yes, we can customize our custom exception class in Python.

Add Methods in Python Custom Exception Class

In Python, we can add methods to custom exception classes, just like we can add methods to any other class. Adding methods to custom exception classes can provide more context about the error and make it easier to handle the exception.

class CustomException(Exception):
    def __init__(self, message):
        self.message = message
    
    def log_error(self):
        # code to log the error message
        pass

In the above example, the log_error method can be used to log the error message when the exception is raised.

We can use the custom exception and its methods in the following way:

try:
    # some code that may raise the exception
    raise CustomException("Error occurred")
except CustomException as e:
    e.log_error()

In the above example, we have caught the CustomException and called its log_error method to log the error message.

Adding methods to custom exception classes can be useful when we want to handle exceptions in a specific way or when we want to provide additional information about the error.

For example, we can add a method to send an email notification when a specific custom exception is raised.

Adding Attributes

Just like adding methods, custom exceptions can also have attributes. These attributes can be used to store additional information about the error that occurred.

To add attributes to a custom exception class, we can define the class constructor and initialize the instance variables.

class CustomException(Exception):
    def __init__(self, message, error_code):
        super().__init__(message)
        self.error_code = error_code

In the above example, the super().init(message) line calls the constructor of the base Exception class and passes the “message” argument to it.

The self.error_code = error_code line initializes the error_code instance variable with the value of the error_code argument.

We can now use this custom exception class to raise exceptions with additional attributes.

try:
    # Some code that may raise an exception
except Exception as e:
    raise CustomException("An error occurred", 500) from e

In the above example, we have used the raise statement to raise a custom exception called CustomException. The exception has a message An error occurred and an error code 500.

The from e clause is used to attach the original exception as the cause attribute of the custom exception. This helps in tracing the cause of the error.

To access the attributes of a custom exception object, we can use the dot notation.

try:
    # Some code that may raise a custom exception
except CustomException as e:
    print("Error message:", e.args[0])
    print("Error code:", e.error_code)

In the above example, we have used the dot notation to access the args tuple of the custom exception object. The first element of the tuple is the message of the exception. We have also accessed the error_code instance variable using the dot notation.

Adding attributes to custom exception classes can help in providing more information about the error that occurred. This can be useful in debugging and resolving the issue.

Python Exception Handling with Method Overriding

Custom exceptions in Python can also override the methods of the base Exception class. Overriding these methods can provide additional functionality and customization to the custom exception.

There are several methods that can be overridden in the Exception class, including str, repr, and cause. Let’s take a look at each of these methods and see how they can be overridden in a custom exception.

str Method

The str method is used to return a string representation of the exception. By default, the str method in the Exception class returns the exception message.

However, we can override this method to customize the string representation of the exception.

class CustomException(Exception):
    def __init__(self, message):
        self.message = message

    def __str__(self):
        return f'CustomException: {self.message}'

In the above example, the str method returns a custom string representation of the exception that includes the name of the exception class and the exception message.

repr Method

The repr method is used to return a string representation of the exception that can be used to recreate the exception object.

By default, the repr method in the Exception class returns a string representation of the exception object that includes the name of the exception class and the exception message.

class CustomException(Exception):
    def __init__(self, message):
        self.message = message

    def __repr__(self):
        return f'CustomException("{self.message}")'

In the above example, the repr method returns a custom string representation of the exception that includes the name of the exception class and the exception message in a format that can be used to recreate the exception object.

cause Method

The cause method is used to set the cause of the exception. By default, the cause method in the Exception class returns None.

However, we can override this method to set the cause of the exception.

class CustomException(Exception):
    def __init__(self, message, cause=None):
        self.message = message
        self.cause = cause

    def __str__(self):
        if self.cause:
            return f'CustomException: {self.message} caused by {self.cause}'
        else:
            return f'CustomException: {self.message}'

    def __cause__(self):
        return self.cause

In the above example, the cause method returns the cause of the exception, which is set using the cause argument in the constructor.

Inherit Custom Exception Class in Python

Sometimes we may want to create a hierarchy of custom exceptions to handle different types of errors. In such cases, we can inherit from the base custom exception class to create a new custom exception class.

Inheritance is a fundamental concept in object-oriented programming that allows us to create new classes that inherit attributes and methods from existing classes.

In Python, we can use the class statement to define a new class that inherits from an existing class.

class ParentException(Exception):
    pass

class ChildException(ParentException):
    pass

In the above example, we have defined two custom exception classes. The first class ParentException is the base class for the second class ChildException.

The ChildException class inherits all the attributes and methods of the ParentException class.

Now, let’s see how we can use the ChildException class in our code.

def divide(a, b):
    if b == 0:
        raise ChildException("Division by zero")
    return a / b

In the above example, if the value of b is zero, we raise a custom exception of type ChildException with the message Division by zero. This allows us to handle the error in a more specific way than using the base Exception class.

We can also define multiple levels of inheritance to create a hierarchy of custom exceptions.

class GrandParentException(Exception):
    pass

class ParentException(GrandParentException):
    pass

class ChildException(ParentException):
    pass

In the above example, we have defined three custom exception classes that form a hierarchy. The ChildException class inherits from the ParentException class, which in turn inherits from the GrandParentException class.

Inheritance allows us to reuse code and create more specialized classes that can handle specific types of errors. It also helps to improve the overall readability and maintainability of the code.

Inherit Built-in Exception Classes in Python

In addition to inheriting from custom exception classes, we can also inherit from the built-in exception classes in Python.

For example, we can create a custom exception class that inherits from the “ValueError” class to handle errors related to invalid values.

class InvalidValueError(ValueError):
    pass

In the above example, we have defined a custom exception class called InvalidValueError that inherits from the built-in ValueError class. This allows us to handle errors related to invalid values in a more specific way than using the base Exception class.

Custom Exceptions Best Practices

To use custom exceptions effectively in your Python code, here are some best practices to follow:

1. Use meaningful and descriptive names for your custom exceptions. The name of the exception should reflect the nature of the error or exceptional situation it represents.
2. Inherit from the appropriate built-in exception class or subclass. If your custom exception represents a file-related error, for example, you should subclass the IOError class.
3. Provide informative error messages that help users and developers to understand the problem and take corrective actions.
4. Handle exceptions properly using the try and except keywords. Always provide a fallback plan to avoid program crashes.
5. Document your custom exceptions in your code comments or documentation to help other developers understand their usage and behavior.

Wrapping Up

In conclusion, Python custom exceptions empower you to handle specific error scenarios beyond the capabilities of built-in exceptions. By creating your own exceptions, extending their behavior, and leveraging them in exception handling, you gain precise control over error messages and recovery mechanisms.

With the knowledge gained from this guide, you’re now equipped to craft exceptional code that gracefully handles unforeseen challenges. So, go forth, embrace the power of custom exceptions, and let your coding wizardry shine!

What’s Next?

As you continue your journey as a coding wizard, there are several other fascinating topics in Python that you may want to explore. Here are some important blogs to further expand your knowledge:

1. Python Generators: Learn how to create memory-efficient and iterable generators that generate values on the fly, saving memory and enhancing performance.
2. Python Decorators: Dive into the world of decorators and discover how to enhance the functionality of functions by wrapping them with additional behavior.
3. Python Enumerate Function: Explore the versatile enumerate() function that adds counter values to iterable objects, making it easier to track indices during iteration.
4. Python Lambda Function: Unleash the power of anonymous functions with Python’s lambda expressions, allowing you to create compact and on-the-fly functions.
5. Python Inner Functions: Delve into the concept of inner functions, nested within other functions, and understand how they provide encapsulation and improve code organization.
6. Python List Comprehension: Discover the concise and expressive syntax of list comprehension, enabling you to create lists in a compact and readable manner.
7. Python Data Class: Learn about Python’s dataclass decorator, which simplifies the creation of classes with automatic attribute handling, comparisons, and more.
8. Python Web Scraping: Explore the world of web scraping, where you can extract data from websites using Python libraries like Beautiful Soup and Requests.
9. Python Web Server: Dive into building web applications with Python using frameworks like Flask or Django, and learn how to serve dynamic content over the web.

By diving into these topics, you’ll expand your Python skills and unlock new possibilities for your coding endeavors. Happy exploring!

References

1. Python Documentation: Exceptions – https://docs.python.org/2/library/exceptions.html