How Do You Raise Exceptions in Python?

You raise an exception with the raise keyword, giving it either a class or an instance to construct.

class InsufficientFundsError(Exception):
    pass


def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(f"cannot withdraw {amount} from {balance}")
    return balance - amount


try:
    withdraw(50, 80)
except InsufficientFundsError as err:
    print("Error:", err)

The raise statement creates an instance of the exception class using the message, and the except clause catches it by type. The message is available on the instance, which is why str(err) gives the text back.

Two rules to know. The exception class must be a subclass of Exception — you cannot raise an arbitrary object, because raise requires something that can be treated as an exception. And when you want to add information to an existing exception, use the three-argument form: raise NewError("message") from original, which sets the cause explicitly and shows both exceptions in the traceback.

That last point is worth an example. If you catch a low-level error and re-raise a higher-level one, the original traceback is attached automatically as the context, so the traceback shows both. Writing from original makes that relationship explicit rather than implicit.

For an interview, the practical guidance is to raise exceptions with a message that says what went wrong and with what values, and to define your own exception classes for the failures callers are expected to handle.

The raise statement takes an exception class or an instance of one. When you pass a class, Python constructs the instance for you with no arguments, which means the class must be constructible with no arguments. When you pass an instance, that exact object is raised.

Written out, the two forms look like this: raising the class gives you the default message, while raising an instance with a message argument gives you your own text.

The distinction matters for custom exceptions that take arguments. A class with a custom __init__ that requires a message cannot be raised bare, because there is nothing to pass to the constructor. So when you write an exception with extra fields — a status code, a resource identifier — you must raise an instance.

There is a second, subtler reason to prefer instances. When you raise the same class twice with different messages, the traceback shows two separate instances and you can tell them apart. If you mutated and reused a single instance, the earlier message would be overwritten.

One more mechanism to mention is the exception group. The ExceptionGroup class, available from Python 3.11, lets you raise several exceptions at once, which is what you want when a function validates several inputs and wants to report every problem rather than only the first. It is caught with except*.