7.3 Raising Exceptions in Python

In Python, you can explicitly trigger exceptions using the raise statement. This is a powerful mechanism for signaling errors or exceptional conditions within your code, particularly when encountering unexpected situations or invalid input that would compromise the integrity or correctness of further execution. By raising exceptions, you can build robust and structured error handling into your applications, significantly improving their reliability, maintainability, and overall resilience.

1. Raising Built-in Exceptions

Python provides a rich library of built-in exceptions, such as ValueError, TypeError, ZeroDivisionError, and FileNotFoundError, which are designed to represent common error scenarios. Utilizing these built-in exceptions is often the most straightforward approach when your code encounters standard, well-understood error conditions.

Syntax:

raise ExceptionType("Descriptive error message")

Example:

def divide(a, b):
    """Divides two numbers, raising ValueError if the divisor is zero."""
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

try:
    result = divide(10, 0)
except ValueError as e:
    print(e)

Output:

Cannot divide by zero

When to use: Use built-in exceptions when your code's error conditions directly map to the semantic meaning of an existing Python exception type.

2. Defining and Raising Custom Exceptions

For situations where built-in exceptions are not sufficiently specific or descriptive for your application's unique logic, you can define your own custom exception classes. This is achieved by creating a new class that inherits from the base Exception class.

Syntax:

class CustomError(Exception):
    pass

You can then raise instances of your custom exception using the raise keyword.

Example:

class MyCustomError(Exception):
    """A custom exception for specific application errors."""
    pass

def risky_function():
    """A function that might raise a custom error."""
    raise MyCustomError("Something unexpected happened in risky_function")

try:
    risky_function()
except MyCustomError as e:
    print(e)

Output:

Something unexpected happened in risky_function

Benefits: Creating custom exceptions enhances code clarity and provides a more descriptive, domain-specific error structure, making it easier to understand and handle errors.

3. Custom Exceptions with Additional Information

Custom exception classes can be further enhanced to carry additional context, such as the specific invalid values encountered. This practice makes error messages more informative and significantly aids in debugging.

Example:

class InvalidAgeError(Exception):
    """Custom exception for invalid age values."""
    def __init__(self, age, message="Age must be between 18 and 100"):
        self.age = age
        self.message = message
        super().__init__(self.message)

def set_age(age):
    """Sets the age, raising InvalidAgeError if the age is out of bounds."""
    if age < 18 or age > 100:
        raise InvalidAgeError(age)
    print(f"Age is set to {age}")

try:
    set_age(150)
except InvalidAgeError as e:
    print(f"Invalid age: {e.age}. {e.message}")

Output:

Invalid age: 150. Age must be between 18 and 100

Best Practice: By attaching attributes to your custom exception instances, you provide rich error information that can be invaluable for logging, debugging, or crafting user-facing feedback.

4. Re-Raising Exceptions in Python

Sometimes, you might need to catch an exception to perform a localized action, such as logging the error, but still want to propagate it to higher levels of your application for further handling. This is achieved by using the raise statement without any arguments within an except block.

Example:

def process_file(filename):
    """Processes a file, logging FileNotFoundError before re-raising."""
    try:
        with open(filename, "r") as file:
            data = file.read()
            # Additional processing logic could go here
            print(f"Successfully read file: {filename}")
    except FileNotFoundError as e:
        print(f"Error: File not found - {filename}. Logging this issue.")
        raise  # Re-raises the caught exception

try:
    process_file("nonexistentfile.txt")
except FileNotFoundError:
    print("Handling the FileNotFoundError at a higher level of application logic.")

Output:

Error: File not found - nonexistentfile.txt. Logging this issue.
Handling the FileNotFoundError at a higher level of application logic.

Usefulness: Re-raising exceptions is particularly beneficial in layered or modular applications where lower-level modules can detect a problem and perform immediate actions (like logging or auditing), while deferring the ultimate decision-making on how to handle the error to a higher, more context-aware layer.

Summary Table

Frequently Asked Questions (FAQ)

• What does the raise statement do in Python? The raise statement is used to explicitly trigger an exception. It stops the normal flow of execution and passes control to the nearest enclosing try...except block that can handle the raised exception.

• How do you raise a built-in exception in Python? Give an example. You raise a built-in exception by specifying its type and optionally providing an error message: raise ValueError("Invalid input value").

• How can you define a custom exception in Python? You define a custom exception by creating a class that inherits from the base Exception class: class MyError(Exception): pass.

• Why would you use custom exceptions instead of built-in exceptions? Custom exceptions are used when built-in exceptions are not specific enough to accurately describe the error condition within your application's domain, leading to clearer error handling and better code readability.

• How can you add extra information to a custom exception in Python? You can add extra information by defining an __init__ method in your custom exception class and storing the additional data as instance attributes.

• What is exception re-raising in Python and why is it useful? Exception re-raising occurs when an exception is caught, some local action is performed (like logging), and then the same exception is raised again using raise without arguments within the except block. It's useful for decoupling error detection from error handling, allowing different layers of an application to manage exceptions appropriately.

• Show how to re-raise an exception after catching it in Python.

  try:
      # code that might raise an exception
      raise ValueError("Something went wrong")
  except ValueError as e:
      print(f"Caught an error: {e}. Performing cleanup...")
      # cleanup actions here
      raise # Re-raise the same exception

• When should you use built-in exceptions versus custom exceptions? Use built-in exceptions for common, universally understood error conditions. Use custom exceptions for application-specific errors that require more descriptive context or when you want to create a distinct error hierarchy for your project.

• Explain how exception handling improves code robustness. Exception handling improves robustness by providing a structured way to anticipate and manage errors. Instead of crashing, the program can gracefully recover, log the issue, or inform the user, ensuring continued operation or a controlled shutdown.

• Can you pass arguments to custom exceptions? If yes, how? Yes, you can pass arguments to custom exceptions by defining an __init__ method in your custom exception class. These arguments can be stored as attributes of the exception instance and accessed when the exception is caught.