User-defined exceptions allow you to create custom exception classes tailored to your specific needs. These exception classes can be used to raise and handle exceptions that are specific to your application or domain.
To
define a user-defined exception class in Python, you can create a new class
that inherits from the base `Exception` class or any of its subclasses.
Typically, it is recommended to derive your custom exception classes from
`Exception` to ensure they adhere to the standard exception hierarchy.
Here's
an example of defining a custom exception class:
class CustomException(Exception):
pass
In
the above code, `CustomException` is a custom exception class that is derived
from the base `Exception` class. The `pass` statement is used to indicate that
the class has no additional functionality or attributes. You can add custom
methods and properties to your exception class as per your requirements.
To
raise a user-defined exception, you can use the `raise` statement followed by
an instance of the custom exception class. You can pass an error message or
additional information to the exception class constructor, which can be
accessed later when handling the exception.
Here's
an example of raising a user-defined exception:
raise CustomException("Custom exception occurred.")
In
the above code, a `CustomException` is raised with a custom error message
"Custom exception occurred."
To
handle user-defined exceptions, you can use `try` and `except` blocks in the
same way as handling built-in exceptions. You can include separate `except`
blocks for each user-defined exception you want to handle, along with a generic
`except` block to handle any other exceptions that may occur.
Here's
an example of handling user-defined exceptions:
try:
# Code that may raise exceptions
raise CustomException("Custom exception occurred.")
except CustomException as e:
# Handle the custom exception
print("Custom exception occurred:", str(e))
except Exception as e:
# Handle other exceptions
print("An error occurred:", str(e))
In
the above code, the `try` block contains the code that may raise a
`CustomException`. If the `CustomException` occurs, the corresponding `except
CustomException` block is executed, where you can provide specific handling for
that exception.
It's
important to handle exceptions properly within the `except` blocks, providing
meaningful error messages, taking appropriate actions, or gracefully recovering
from the exception if possible.
By
defining and handling user-defined exceptions, you can create more robust and
maintainable code that effectively communicates and handles exceptional
situations specific to your application or domain.