7.3 Raising Exceptions

Raising exceptions in Python allows you to handle errors in a custom manner and ensure that your program behaves as expected when encountering unusual situations or conditions. When an exceptional condition arises, you can "raise" an exception explicitly using the raise keyword. This gives you full control over error handling in your programs.

1. Why Raise Exceptions?

You should raise exceptions when:

• You detect an error condition in your code (e.g., invalid input, unexpected behavior).
• You want to enforce certain conditions in your program (e.g., ensuring a value is within a specific range).
• You want to propagate an error back to the calling function (e.g., inside a library or framework) and handle it later.

Raising exceptions allows you to control the flow of your program, letting you stop execution, log the error, and handle it appropriately in the calling code.

2. Syntax of Raising an Exception

The basic syntax for raising an exception is:

raise ExceptionType("Error message")

Where:

• ExceptionType is the type of the exception (e.g., ValueError, TypeError).
• "Error message" is a string describing the error.

You can also raise a built-in exception or a custom one.

3. Raising Built-in Exceptions

Python provides many built-in exceptions, such as ValueError, TypeError, IndexError, etc. You can raise them when certain conditions are met.

age = -5

if age < 0:
    raise ValueError("Age cannot be negative")

• Explanation: If the age is less than 0, the program raises a ValueError with the message "Age cannot be negative". This helps inform the user that the input value is invalid.

4. Raising Custom Exceptions

You can also define your own custom exceptions by creating a class that inherits from the built-in Exception class.

class NegativeAgeError(Exception):
    def __init__(self, message="Age cannot be negative"):
        self.message = message
        super().__init__(self.message)

def set_age(age):
    if age < 0:
        raise NegativeAgeError("Provided age is negative")
    return age

try:
    set_age(-5)
except NegativeAgeError as e:
    print(f"Error: {e}")

• Explanation: The custom exception NegativeAgeError is raised when an invalid age is provided. This custom exception gives more context about the error and makes the code more meaningful.

5. Raising Exceptions with Assertions

You can also use assert to raise exceptions when certain conditions are not met. This is typically used for debugging or validating input data.

x = -1
assert x >= 0, "x must be greater than or equal to 0"

• Explanation: The assert statement checks the condition (x >= 0). If it’s False, it raises an AssertionError with the given message ("x must be greater than or equal to 0").

6. Raising Exceptions in Functions

Raising exceptions can be particularly useful in functions to prevent invalid operations or provide early feedback.

def withdraw_balance(balance, amount):
    if amount > balance:
        raise ValueError("Insufficient funds")
    return balance - amount

try:
    balance = withdraw_balance(100, 200)
except ValueError as e:
    print(f"Error: {e}")

• Explanation: If a user tries to withdraw an amount greater than their balance, the function raises a ValueError with the message "Insufficient funds".

7. Re-Raising Exceptions

In some cases, you may want to catch an exception, log or handle it, and then re-raise the exception to propagate it further up the call stack.

def process_data(data):
    try:
        # Some code that may raise an exception
        result = int(data)
    except ValueError as e:
        print(f"Error: {e}")
        raise  # Re-raises the caught exception

try:
    process_data("invalid_data")
except ValueError as e:
    print(f"Handled exception: {e}")

• Explanation: The ValueError is caught in the process_data function, logged, and then re-raised to be handled by the calling code. This approach allows for better error tracing and flexibility in handling exceptions.

8. Best Practices for Raising Exceptions

• Use exceptions for exceptional cases, not for control flow. Exceptions should represent unexpected or erroneous situations.
• Provide meaningful error messages to help users or developers understand what went wrong.
• Use custom exceptions when you need more specific error handling tailored to your program’s needs.
• Avoid overusing exceptions for predictable conditions. Instead, use conditionals (if-else) where appropriate.
• Document exceptions: Always document the exceptions that can be raised in your functions or classes to inform users about the potential errors.

9. Example: Custom Exception for Age Validation

class AgeValidationError(Exception):
    def __init__(self, message="Invalid age provided"):
        self.message = message
        super().__init__(self.message)

def validate_age(age):
    if age < 0 or age > 120:
        raise AgeValidationError("Age must be between 0 and 120")
    return age

try:
    validate_age(150)
except AgeValidationError as e:
    print(f"Error: {e}")

• Explanation: Here, AgeValidationError is a custom exception that is raised if an age is less than 0 or greater than 120, providing a clear error message.

Conclusion

Raising exceptions in Python allows you to handle errors more effectively and create programs that are easier to debug and maintain. By using built-in exceptions, creating custom exceptions, and following best practices, you can ensure that your programs can gracefully handle a variety of error scenarios.