Learn Python Programming

Python Exception Handling

Exception handling uses try, except, else, and finally blocks to gracefully manage errors, run cleanup code, and keep programs running.

try / except / else / finally

# Full exception handling structure
try:
    # Code that might raise an exception
    file = open("data.txt", "r")
    content = file.read()
    number = int(content.strip())
except FileNotFoundError:
    # Runs if file does not exist
    print("File not found — using default value")
    number = 0
except ValueError:
    # Runs if content is not a valid integer
    print("File content is not a number")
    number = 0
else:
    # Runs ONLY if no exception was raised
    print(f"Successfully read number: {number}")
finally:
    # ALWAYS runs — for cleanup
    print("Done processing")

# Output depends on what happens:
# File missing → "File not found..." → "Done processing"
# Bad content  → "File content is..." → "Done processing"
# Success      → "Successfully read..." → "Done processing"

Catching Multiple Exceptions

# Multiple except blocks (most specific first)
def parse_config(filename):
    try:
        with open(filename) as f:
            data = f.read()
        config = eval(data)  # risky but illustrative
        return config["database"]["host"]
    except FileNotFoundError:
        print(f"Config file {filename} not found")
    except (KeyError, TypeError) as e:
        # Catch multiple exceptions in one block
        print(f"Invalid config structure: {e}")
    except Exception as e:
        # Catch-all for unexpected errors (use sparingly)
        print(f"Unexpected error: {type(e).__name__}: {e}")
    return None

# Catch any exception (last resort)
try:
    risky_operation()
except Exception as e:
    # Logs the error but does not hide KeyboardInterrupt/SystemExit
    print(f"Error: {e}")

The finally Block

# finally ALWAYS runs — even if you return or raise inside try/except
def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        return None
    finally:
        print("divide() completed")  # always prints

print(divide(10, 2))   # "divide() completed" then 5.0
print(divide(10, 0))   # "divide() completed" then None

# Common use: resource cleanup
connection = None
try:
    connection = connect_to_database()
    connection.execute("SELECT * FROM users")
except DatabaseError as e:
    print(f"Query failed: {e}")
finally:
    if connection:
        connection.close()  # always close, even on error
        print("Connection closed")

Practical Error Handling Patterns

# Pattern 1: Retry with backoff
import time

def fetch_with_retry(url, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = make_request(url)
            return response
        except ConnectionError:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # exponential backoff
                print(f"Retry {attempt + 1} in {wait}s...")
                time.sleep(wait)
            else:
                raise  # re-raise on final attempt

# Pattern 2: Input validation loop
def get_positive_number():
    while True:
        try:
            value = int(input("Enter a positive number: "))
            if value <= 0:
                raise ValueError("Must be positive")
            return value
        except ValueError as e:
            print(f"Invalid: {e}. Try again.")

# Pattern 3: Graceful degradation
def load_user_settings(path):
    """Load settings from file, fall back to defaults on any error."""
    defaults = {"theme": "light", "font_size": 14, "language": "en"}
    try:
        import json
        with open(path) as f:
            settings = json.load(f)
        # Merge with defaults (user settings override)
        return {**defaults, **settings}
    except (FileNotFoundError, json.JSONDecodeError, PermissionError):
        return defaults

Best Practices

# DO: Catch specific exceptions
try:
    value = my_dict[key]
except KeyError:
    value = default

# DON'T: Bare except catches everything (including Ctrl+C!)
# try:
#     do_something()
# except:          # BAD — catches KeyboardInterrupt too
#     pass

# DO: Use context managers instead of try/finally for files
with open("file.txt") as f:
    content = f.read()
# File is automatically closed, even if an error occurs

# DO: Log errors before handling them
import logging

try:
    process_order(order)
except PaymentError as e:
    logging.error(f"Payment failed for order {order.id}: {e}")
    notify_customer(order, "payment_failed")
    raise  # or handle gracefully

• else runs only if no exception occurred — put success logic there.
• finally always runs — use it for cleanup (closing files, connections).
• Catch specific exceptions, not bare except: which hides bugs.
• Use with statements (context managers) instead of try/finally for resources.
• Log errors before handling them — silent failures are hard to debug.