3. Raising and Customizing Exceptions

Quiz: 0/5

This lesson teaches you how to raise exceptions and create custom exceptions in Python. By the end, you’ll understand how to handle errors more effectively and make your programs more reliable.

Using raise to trigger Exceptions

Exceptions are a way of signaling that something went wrong in your program. In Python, the raise keyword allows you to manually trigger an exception when a certain condition occurs.

Example:

def check_positive(num):
    if num < 0:
        raise ValueError("The number must be positive!")
    return num

In this example, if the number is negative, Python raises a ValueError, and the message "The number must be positive!" is displayed.

Creating custom Exceptions with class CustomError(Exception)

Sometimes, the built-in exceptions like ValueError or TypeError might not be descriptive enough for your specific case. You can create your own custom exception by defining a new class that inherits from Python’s built-in Exception class.

This gives you the power to create exceptions that are tailored to your program’s needs.

Example:

class CustomError(Exception):
    def __init__(self, message):
        super().__init__(message)  # Pass the message to the base class

def check_positive(num):
    if num < 0:
        raise CustomError("Oops! Negative numbers are not allowed!")

Here, the CustomError exception is raised with a message that’s more specific to the problem you're solving, rather than using a generic ValueError.

When and why to use custom Exceptions

Why use custom Exceptions?

Custom exceptions allow you to handle specific errors in your code more clearly and meaningfully. They make your code easier to debug and maintain by providing more context when an error occurs.

When to use custom Exceptions?

When built-in exceptions don’t quite fit your needs. For example, if you're building a banking app, you might want a custom exception like NegativeBalanceError to handle cases where an account balance goes negative.

Custom exceptions also help other developers understand what went wrong and why, just by looking at the exception name.

Example:

class NegativeBalanceError(Exception):
    def __init__(self, balance):
        self.balance = balance
        super().__init__(f"Balance cannot be negative: {balance}")

def withdraw(balance, amount):
    if balance - amount < 0:
        raise NegativeBalanceError(balance)
    return balance - amount

Conclusion:

By learning how to raise and customize exceptions, you gain better control over how your program handles errors. Custom exceptions provide a way to make your code more readable and specific to your needs, improving both its reliability and ease of maintenance. By creating meaningful exceptions, you make it clear what went wrong and how to fix it, which is crucial for larger or more complex programs.