Exception Handling

Introduction

No matter how carefully you write code, things can go wrong at runtime: a user might type text instead of a number, a file might be missing, or a network request might fail. These runtime problems are called exceptions, and if left unhandled, they crash your program immediately.

Python gives you a clean way to anticipate and handle these problems using try, except, else, and finally. This lesson teaches you how to catch errors gracefully, respond to specific problems differently, and raise your own errors when something is wrong.

Why Exception Handling Matters

Without exception handling, a single unexpected error stops your entire program dead, printing a scary-looking traceback and losing any unsaved work. Exception handling lets your program anticipate likely problems and respond sensibly — showing a friendly message, retrying, or skipping the problem — instead of crashing.

try and except

Code that might fail goes inside a try block. If an error occurs, Python immediately jumps to the matching except block instead of crashing the program.

try:
    number = int(input("Enter a number: "))
    print("You entered:", number)
except:
    print("That was not a valid number!")

That was not a valid number!

The bare except: above catches any error at all, which is convenient but hides useful information about exactly what went wrong. The next section shows a better approach.

Catching Specific Exception Types

Python has many built-in exception types, each describing a specific kind of problem. Catching the specific type lets you respond appropriately to each situation, and lets unexpected errors still surface clearly instead of being silently hidden.

try:
    number = int(input("Enter a number: "))
    result = 100 / number
    print("Result:", result)
except ValueError:
    print("That is not a valid whole number.")
except ZeroDivisionError:
    print("You cannot divide by zero.")

You cannot divide by zero.

Python checks each except clause in order and runs the first one that matches the type of exception that was raised.

data = {"name": "Alex", "age": 16}

try:
    with open("missing.txt", "r") as file:
        print(file.read())
    print(data["email"])
except FileNotFoundError:
    print("The file could not be found.")
except KeyError:
    print("That key does not exist in the dictionary.")

The file could not be found.

Notice that as soon as the FileNotFoundError happens, Python jumps straight to its except block — the print(data["email"]) line never even runs, so its KeyError never gets a chance to occur here.

The else Clause

An optional else block runs only if the try block completed with no exceptions at all. It is useful for code that should run only on success, keeping it separate from the risky code in try.

try:
    number = int("42")
except ValueError:
    print("Conversion failed.")
else:
    print("Conversion succeeded! Number is:", number)

Conversion succeeded! Number is: 42

The finally Clause

A finally block always runs, whether an exception occurred or not, and even if the exception was not caught by any except clause. It is the ideal place for cleanup code, like closing a file or a network connection.

try:
    number = int("not a number")
except ValueError:
    print("Could not convert to a number.")
finally:
    print("This always runs, no matter what.")

Could not convert to a number.
This always runs, no matter what.

Raising Exceptions with raise

Sometimes you want to signal an error yourself, rather than waiting for Python to raise one naturally. The raise keyword lets you trigger an exception on purpose, which is especially useful inside functions that validate their input.

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Insufficient funds for this withdrawal.")
    return balance - amount

try:
    new_balance = withdraw(100, 250)
except ValueError as error:
    print("Error:", error)

Error: Insufficient funds for this withdrawal.

Using as error captures the exception object so you can inspect or print its message, rather than just knowing that some error occurred.

Custom Exceptions (A Quick Preview)

Python also lets you define your own exception types by creating a class that inherits from Exception. This is a preview only — classes and inheritance are covered in depth starting with the next few lessons on object-oriented programming.

class InsufficientFundsError(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError("Not enough money in the account.")
    return balance - amount

try:
    withdraw(100, 500)
except InsufficientFundsError as error:
    print("Custom error caught:", error)

Custom error caught: Not enough money in the account.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Exception handling lets your Python programs anticipate and gracefully recover from runtime errors instead of crashing. You learned how try and except catch problems, how else and finally control what runs and when, and how raise lets you signal your own errors.