Exception Handling in Python

An exception is an event that disrupts the normal flow of a program's instructions, typically raised when an error occurs — dividing by zero, accessing a missing dictionary key, or opening a file that doesn't exist. Rather than letting an unhandled exception crash the program with a traceback, Python lets you anticipate and handle specific error conditions gracefully using try/except blocks.

Exception handling is not just for "true" errors, either. It is also Python's standard mechanism for signaling and reacting to any exceptional condition your own code needs to communicate, through custom exception classes.

Why it matters

Files go missing, users type letters where numbers are expected, and networks fail. A program that does not handle these stops with a traceback; one that does can report the problem and carry on. Exception handling is how Python code deals with everything that can go wrong at runtime, and every production program relies on it.

try, except, else, and finally

A full exception-handling block has four parts, each with a distinct purpose.

• try — contains the code that might raise an exception.
• except ExceptionType: — runs only if that specific exception type (or a subclass of it) was raised in the try block; you can have multiple except clauses to handle different error types differently.
• else — runs only if the try block completed with no exception at all; useful for code that should run only on success, without being part of what is guarded by except.
• finally — always runs, whether an exception occurred or not, and even if the exception was not caught; commonly used for cleanup like closing files or network connections.

Raising Exceptions

You raise an exception explicitly with the raise keyword, either raising a built-in exception type like ValueError("message") or re-raising a caught exception with a bare raise inside an except block (which preserves the original traceback). Raising early with a clear message, rather than letting invalid data propagate silently, makes bugs far easier to diagnose.

Custom Exception Classes

For application-specific error conditions, you can define your own exception class by inheriting from Exception (or a more specific built-in exception). This lets calling code catch exactly your application's errors — such as InsufficientFundsError — separately from generic Python errors, and lets you attach extra data (like an account balance) to the exception object itself.

Examples

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero.")
        return None
    except TypeError:
        print("Both arguments must be numbers.")
        return None
    else:
        print("Division succeeded.")
        return result
    finally:
        print("safe_divide finished.")

print(safe_divide(10, 2))
print(safe_divide(10, 0))

Division succeeded.
safe_divide finished.
5.0
Cannot divide by zero.
safe_divide finished.
None

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        super().__init__(f"Cannot withdraw {amount}; balance is only {balance}")
        self.balance = balance
        self.amount = amount

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    withdraw(100, 250)
except InsufficientFundsError as e:
    print(str(e))
    print(e.balance, e.amount)

Cannot withdraw 250; balance is only 100
100 250

Exercise

Write safe_divide. It returns the result of the division, or None when the divisor is zero, and in both cases prints done before returning.

Expected output: done, 5.0, done, None (one per line)

def safe_divide(a, b):
    # TODO: try the division and return the result
    # TODO: return None if a ZeroDivisionError occurs
    # TODO: print "done" in every case
    pass


print(safe_divide(10, 2))
print(safe_divide(10, 0))

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
    finally:
        print("done")


print(safe_divide(10, 2))
print(safe_divide(10, 0))

Quick quiz

Interview questions