What is the proper way to declare a Python custom exception in modern Python?

General Discussions
,
1

What is the proper way to declare a Python custom exception in modern Python?

I want to follow the standard practices for defining exception classes to ensure that any additional information, such as strings or other relevant data, is correctly displayed when the exception is caught. By “modern Python,” I mean something that works in Python 2.5 while being “correct” for Python 2.6 and 3.x.

The goal is to create a custom exception that includes extra data about the error, such as a descriptive message and other arbitrary objects. However, I encountered a deprecation warning in Python 2.6.2 when attempting the following:

class MyError(Exception):  
    def __init__(self, message):  
        self.message = message  
 
MyError("foo")

The warning states:
DeprecationWarning: BaseException.message has been deprecated as of Python 2.6.

From PEP-352, it seems the message attribute had special meaning in Python 2.5, but it’s now deprecated. Does this mean using message is forbidden? Additionally, I’ve read about the args attribute in Exception, but I’m unsure how to use it or if it’s the recommended approach for modern Python versions.

Do I need to override __init__, __str__, and similar methods for defining a Python custom exception, or is there a simpler standard way to achieve this?

2

The simplest way to create a Python custom exception is by leveraging the args attribute that comes with the base Exception class. This avoids the deprecated message attribute:

class MyError(Exception):  
    def __init__(self, *args):  
        super().__init__(*args)  

try:  
    raise MyError("This is a custom error message.")  
except MyError as e:  
    print(e)  # Outputs: This is a custom error message.

This method adheres to modern practices and works across Python 2.5, 2.6, and 3.x.

3

For a more detailed Python custom exception, you can add specific attributes while following the deprecation guidelines:

class MyError(Exception):  
    def __init__(self, message, data=None):  
        self.message = message  
        self.data = data  
        super().__init__(message)  

    def __str__(self):  
        return f"{self.message} (Data: {self.data})"  

try:  
    raise MyError("An error occurred", data={"code": 123})  
except MyError as e:  
    print(e)  # Outputs: An error occurred (Data: {'code': 123})

This approach lets you include additional context without relying on deprecated attributes.

4

If you need a readable message for your Python custom exception, overriding str or repr can simplify debugging:

class MyError(Exception):  
    def __init__(self, message):  
        super().__init__(message)  

    def __str__(self):  
        return f"MyError: {self.args[0]}"  

try:  
    raise MyError("Custom error with a detailed message.")  
except MyError as e:  
    print(e)  # Outputs: MyError: Custom error with a detailed message.

This ensures compatibility with Python 2.5, 2.6, and 3.x while adhering to best practices for custom exceptions.