Raising and Handling Exceptions

Why Generic Errors Are Not Always Enough

Python provides built-in exceptions such as ValueError and TypeError for common problems. However, an application often has conditions that are specific to its own rules. A text-input validator, for example, may need to represent the condition that an input is too short. A custom exception gives that condition a clear name instead of forcing it into a generic error category.

Defining the Exception Class

Define a custom exception by creating a class whose superclass is Exception. The class name describes the application condition that the exception represents. A minimal class can contain pass, meaning that it adds no methods or attributes beyond what it inherits from Exception.

class ShortInputException(Exception):
    pass

The inheritance chain from BaseException through Exception to ShortInputException makes the custom exception compatible with Python's exception-handling system. It can be handled by an except block that catches the custom type, Exception, or BaseException.

Storing Useful Error Details

A custom exception becomes more useful when it carries information about the problem. Add an __init__ method to store relevant details as instance attributes. In the ShortInputException example, the exception stores the actual input length and the minimum length required.

class ShortInputException(Exception):
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

The __init__ method receives length and atleast as arguments. It calls Exception.__init__(self) to initialize the parent Exception class, then stores the two values as instance attributes. Code that catches the exception can later read those attributes and respond to the exact error details.

Following Control After raise

Use the raise statement to create and throw an exception. The exception class name follows raise, along with the arguments required by its __init__ method. When the raise statement executes, normal execution stops at that point. Control immediately moves to the nearest enclosing try-except block that can handle the exception type.

class ShortInputException(Exception): def __init__(self, length, atleast): Exception.__init__(self) self.length = length self.atleast = atleast text = "hi" try: if len(text) < 3: raise ShortInputException(len(text), 3) except ShortInputException as error: print(error.length) print(error.atleast)

2
3

Handling the Domain Condition

class ShortInputException(Exception):
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

text = "hello"

try:
    if len(text) < 3:
        raise ShortInputException(len(text), 3)
except ShortInputException as error:
    print("Input was too short")
    print("Actual length:", error.length)
    print("Required length:", error.atleast)
else:
    print("Input accepted")

Input accepted

With the input set to hello, the length is at least 3, so the raise statement does not execute. The except block is skipped and the else block confirms successful input. If the input contained fewer than 3 characters, the custom exception would be raised and the handler would use its stored length and atleast values.

Mistakes with Custom Exceptions

• Defining the custom class without inheriting from Exception

  The custom class is not connected to Exception through the inheritance chain described for Python exception handling.

  Fix: Define it as class ShortInputException(Exception):

• Raising the exception without the arguments required by __init__

  The example exception's __init__ method expects the actual length and the minimum length.

  Fix: Pass both values, such as raise ShortInputException(len(text), 3).

• Catching the exception but ignoring its stored details

  The handler misses the length and atleast attributes that can make the feedback more specific.

  Fix: Bind the object with as and access its attributes, such as except ShortInputException as error.

• Expecting execution to continue after raise inside the try block

  When raise executes, control immediately moves to the nearest enclosing try-except block that can handle the exception.

  Fix: Place handling logic in the matching except block.

Practice and Recall

Key Takeaways

1. A custom exception is a user-defined class that inherits from Exception.
2. A minimal custom exception can use pass, while an __init__ method can store useful error details.
3. The raise statement creates the custom exception and passes arguments to its __init__ method.
4. When raise executes, control moves to the nearest matching try-except handler.
5. Custom exceptions make domain-specific error conditions clearer and allow handlers to provide targeted responses.