How will you explain that an exception is an object in Python?

In Python, exceptions are not just error messages; they are actual objects. Understanding that exceptions are objects helps you work with them more effectively, such as accessing their attributes or creating custom exceptions.

What do We mean by Exception is an Object?

When an exception occurs, Python creates an instance of an exception class. This instance contains information about the error, like its type, message, and traceback. Since exceptions are objects, you can interact with them just like any other Python object.

Example: Catching an exception object

In the following example, we catch a ZeroDivisionError and assign it to a variable e. This variable is an exception object that we can inspect or use ?

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Caught an exception object: {e}")
    print(f"Type of exception object: {type(e)}")

The output shows the exception message and its type ?

Caught an exception object: division by zero
Type of exception object: <class 'ZeroDivisionError'>

Attributes and Methods of Exception Objects

Exception objects have useful attributes and methods that provide details about the error. For example, the args attribute holds the arguments passed to the exception.

Example: Accessing exception attributes

In this example, we print the args attribute of the caught exception object ?

try:
    int("abc")
except ValueError as e:
    print("Exception args:", e.args)
    print("Exception message:", str(e))
    print("Exception class name:", e.__class__.__name__)

The output shows the message arguments stored in the exception object ?

Exception args: ("invalid literal for int() with base 10: 'abc'",)
Exception message: invalid literal for int() with base 10: 'abc'
Exception class name: ValueError

Create and Raise Your Own Exception Objects

Since exceptions are objects, you can define your own exception classes by inheriting from built-in exception classes. Then you can raise instances of these classes in your code.

Example: Custom exception with additional attributes

In this example, we create a custom exception class with additional attributes and raise an instance of it ?

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

try:
    raise MyCustomError("This is a custom exception object.", 404)
except MyCustomError as e:
    print(f"Caught custom exception: {e}")
    print(f"Error code: {e.error_code}")
    print(f"Exception type: {type(e)}")

The output confirms the custom exception object was raised and caught ?

Caught custom exception: This is a custom exception object.
Error code: 404
Exception type: <class '__main__.MyCustomError'>

Exception Object Inheritance

Since exceptions are objects, they follow Python's object-oriented principles. All exception classes inherit from the BaseException class ?

try:
    raise ValueError("Sample error")
except Exception as e:
    print("Exception object:", e)
    print("Is instance of Exception?", isinstance(e, Exception))
    print("Is instance of BaseException?", isinstance(e, BaseException))
    print("Method Resolution Order:", type(e).__mro__)

Exception object: Sample error
Is instance of Exception? True
Is instance of BaseException? True
Method Resolution Order: (<class 'ValueError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

Why is it Important that Exceptions are Objects?

Because exceptions are objects, you can:

• Pass them around your code like any other object
• Access detailed information about the error through attributes
• Create custom exceptions with additional functionality and data
• Use object-oriented principles like inheritance and polymorphism
• Store exceptions in data structures for later processing

Conclusion

Understanding that exceptions are objects in Python allows you to leverage their attributes and methods for better error handling. This object-oriented approach enables you to create sophisticated custom exceptions and build more robust error handling systems.