Exception Handling: Writing Resilient Python Programs

Every program eventually encounters something unexpected: a missing file, an invalid user input, a network timeout, a division by zero. Python’s exception-handling system lets you anticipate these situations, recover gracefully, and give users — and yourself — meaningful error messages instead of confusing stack traces. This page walks you from the basics of try/except all the way to creating your own exception hierarchy.

What is an Exception?

An exception is a runtime error — something went wrong while the program was running, not while it was being compiled. Python stops execution and raises an exception object. If nothing catches it, the program crashes and prints a traceback.

# This crashes with ZeroDivisionError
result = 10 / 0

# This crashes with ValueError
number = int("hello")

# This crashes with KeyError
data = {"name": "Alice"}
print(data["age"])

try / except

Wrap risky code in a try block. If an exception occurs, Python jumps to the matching except block instead of crashing:

try:
    number = int(input("Enter a number: "))
    print(f"You entered: {number}")
except ValueError:
    print("That's not a valid number. Please enter digits only.")

Without the try/except, a bad input would crash the program. With it, the user gets a friendly message and the program continues.

Catching Specific Exception Types

Always catch the most specific exception type you expect. Catching broad exceptions hides real bugs.

try:
    with open("data.txt", "r") as f:
        content = f.read()
    value = int(content.strip())
    result = 100 / value
    print(f"Result: {result}")

except FileNotFoundError:
    print("Error: the file 'data.txt' does not exist.")

except ValueError:
    print("Error: the file does not contain a valid integer.")

except ZeroDivisionError:
    print("Error: the number in the file must not be zero.")

Common Built-in Exception Types

Exception	When it occurs
`ValueError`	Right type, wrong value — e.g., `int("hello")`
`TypeError`	Wrong type entirely — e.g., `"2" + 2`
`KeyError`	Dictionary key not found
`IndexError`	List index out of range
`FileNotFoundError`	File or directory does not exist
`ZeroDivisionError`	Division or modulo by zero
`AttributeError`	Attribute does not exist on the object
`ImportError`	Module cannot be found or imported

Catching Multiple Types at Once

try:
    data = process(raw_input)
except (ValueError, TypeError) as error:
    print(f"Input error: {error}")

Accessing the Exception Object

The as error clause binds the exception to a variable, letting you log or display the error message:

try:
    result = 10 / 0
except ZeroDivisionError as error:
    print(f"Caught: {error}")   # Caught: division by zero

The `else` Clause

The else block runs only if the try block completed without raising any exception. Use it for code that should only execute when the risky operation succeeded:

try:
    number = int(input("Enter a positive number: "))
except ValueError:
    print("Invalid input — not a number.")
else:
    # Only runs if int() succeeded
    squared = number ** 2
    print(f"{number} squared is {squared}.")

Put only the minimal risky operation inside try. Move follow-on logic to else. This way you can be certain your except blocks are not silently swallowing unrelated errors.

The `finally` Clause

The finally block always runs — whether the try succeeded, the except caught something, or even if the program is about to re-raise an exception. Use it to release resources like file handles, database connections, or network sockets:

file = None
try:
    file = open("report.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("File not found.")
finally:
    if file and not file.closed:
        file.close()
    print("Cleanup complete.")   # always printed

The with statement (context manager) is usually a cleaner alternative to finally for file handling, because it closes the file automatically even when an exception occurs.

try:
    with open("report.txt", "r") as f:
        print(f.read())
except FileNotFoundError:
    print("File not found.")

Raising Exceptions

Use raise to trigger an exception yourself when your code detects that a rule has been broken:

def set_age(age):
    if not isinstance(age, int):
        raise TypeError(f"Age must be an int, got {type(age).__name__}.")
    if age < 0 or age > 150:
        raise ValueError(f"Age {age} is out of the valid range 0–150.")
    return age

print(set_age(25))     # 25
print(set_age(-1))     # raises ValueError
print(set_age("old"))  # raises TypeError

Re-raising an Exception

Inside an except block, call raise with no argument to re-raise the current exception after doing some logging or cleanup:

import logging

try:
    result = 10 / 0
except ZeroDivisionError:
    logging.error("Division by zero encountered")
    raise   # re-raise so the caller knows something went wrong

Creating Custom Exception Classes

For larger applications, define domain-specific exceptions by subclassing Exception. This makes error handling precise and self-documenting.

# Base exception for the whole application
class AppError(Exception):
    """Base class for all application errors."""
    pass

# More specific errors
class ValidationError(AppError):
    """Raised when input data fails validation rules."""
    pass

class InsufficientStockError(AppError):
    """Raised when a product does not have enough stock to fulfil an order."""
    def __init__(self, product_name, requested, available):
        self.product_name = product_name
        self.requested    = requested
        self.available    = available
        super().__init__(
            f"Cannot fulfil order for '{product_name}': "
            f"requested {requested}, only {available} in stock."
        )

Using the custom exceptions:

def place_order(product_name, quantity, stock):
    if quantity <= 0:
        raise ValidationError("Quantity must be greater than zero.")
    if quantity > stock:
        raise InsufficientStockError(product_name, quantity, stock)
    print(f"Order placed: {quantity}× {product_name}")

try:
    place_order("Laptop", 3, 1)
except ValidationError as e:
    print(f"Validation problem: {e}")
except InsufficientStockError as e:
    print(f"Stock problem: {e}")
    print(f"Shortage: {e.requested - e.available} units")

Output:

Stock problem: Cannot fulfil order for 'Laptop': requested 3, only 1 in stock.
Shortage: 2 units

Practical Example: Reading a File with Full Error Handling

The following function reads a configuration file, parses it as JSON, and returns a settings dictionary — with proper handling for every realistic failure mode:

import json

class ConfigError(Exception):
    """Raised when configuration cannot be loaded or parsed."""
    pass

def load_config(filepath):
    """
    Load JSON configuration from a file.

    Args:
        filepath (str): Path to the JSON config file.

    Returns:
        dict: Parsed configuration data.

    Raises:
        ConfigError: If the file is missing, unreadable, or contains invalid JSON.
    """
    try:
        with open(filepath, "r", encoding="utf-8") as f:
            raw = f.read()

    except FileNotFoundError:
        raise ConfigError(f"Config file not found: {filepath}")

    except PermissionError:
        raise ConfigError(f"No read permission for: {filepath}")

    else:
        try:
            config = json.loads(raw)
        except json.JSONDecodeError as e:
            raise ConfigError(f"Invalid JSON in {filepath}: {e}")
        return config

    finally:
        print(f"[load_config] Attempted to load: {filepath}")


# --- Usage ---
try:
    settings = load_config("config.json")
    host = settings.get("host", "localhost")
    port = settings.get("port", 8000)
    print(f"Connecting to {host}:{port}")

except ConfigError as e:
    print(f"Cannot start application — {e}")

Best Practices

Catch specific exceptions

Never write except: or except Exception: without a good reason. Catching bare exceptions swallows bugs, including KeyboardInterrupt and SystemExit.

Fail fast

Raise an exception as soon as you detect invalid input or an impossible state. Delaying the error makes it much harder to trace back to the root cause.

Log, then decide

Log the original exception before re-raising or raising a new one. Use Python’s logging module — print() is not suitable for production error reporting.

Use custom exceptions

Define a base exception class for your application (e.g., AppError) and derive specific ones from it. Callers can then catch either the specific type or the whole application family.

The else clause is often overlooked but is genuinely useful. It signals clearly that the code in that block depends on the try having succeeded — which is better than tucking that code at the end of the try block where it could accidentally catch unrelated exceptions.

Core Python

Advanced Python

Pydantic

Exception Handling: Writing Resilient Python Programs

What is an Exception?

try / except

Catching Specific Exception Types

Common Built-in Exception Types

Catching Multiple Types at Once

Accessing the Exception Object

The `else` Clause

The `finally` Clause

Raising Exceptions

Re-raising an Exception

Creating Custom Exception Classes

Practical Example: Reading a File with Full Error Handling

Best Practices

Catch specific exceptions

Fail fast

Log, then decide

Use custom exceptions

​What is an Exception?

​try / except

​Catching Specific Exception Types

​Common Built-in Exception Types

​Catching Multiple Types at Once

​Accessing the Exception Object

​The else Clause

​The finally Clause

​Raising Exceptions

​Re-raising an Exception

​Creating Custom Exception Classes

​Practical Example: Reading a File with Full Error Handling

​Best Practices

Catch specific exceptions

Fail fast

Log, then decide

Use custom exceptions

What is an Exception?

try / except

Catching Specific Exception Types

Common Built-in Exception Types

Catching Multiple Types at Once

Accessing the Exception Object

The `else` Clause

The `finally` Clause

Raising Exceptions

Re-raising an Exception

Creating Custom Exception Classes

Practical Example: Reading a File with Full Error Handling

Best Practices