Handling errors

Handling errors in Python is essential for writing robust, production-ready code — exceptions are the primary mechanism for signaling and responding to runtime problems (invalid input, I/O failures, network errors, type mismatches, etc.). The try/except/else/finally block provides fine-grained control: execute risky code in try, catch specific exceptions in except, run success-only code in else, and guarantee cleanup in finally. In 2026, effective error handling is non-negotiable — it prevents crashes in data pipelines, web apps, ML training, scraping, and APIs, enables logging/monitoring, graceful degradation, user-friendly messages, and reliable resource cleanup (files, connections, locks). Poor handling leads to silent failures, data corruption, or uninformative stack traces; good handling makes systems resilient and debuggable.

Here’s a complete, practical guide to handling errors in Python: core try/except/else/finally patterns, exception hierarchy, custom exceptions, logging, real-world patterns, and modern best practices with type hints, context managers, and pandas/Polars integration.

Basic try/except — catch specific exceptions, provide recovery or logging.


try:
    result = 1 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")          # Error: division by zero
    result = 0                    # recovery
else:
    print("No error occurred")    # skipped on exception
finally:
    print("Cleanup always runs")  # always executes

Multiple except blocks — handle different exceptions differently; use bare except or Exception as last resort (never catch BaseException unless intentional).


try:
    value = int(input("Enter a number: "))
    result = 100 / value
except ValueError:
    print("Invalid input — not a number")
except ZeroDivisionError:
    print("Cannot divide by zero")
except Exception as e:           # broad catch-all (last)
    print(f"Unexpected error: {type(e).__name__}: {e}")
else:
    print(f"Success: {result}")
finally:
    print("Done processing")

Real-world pattern: safe file + data processing in pandas/Polars — use try/except + finally for cleanup, or context managers for automatic handling.


import pandas as pd
from contextlib import contextmanager

@contextmanager
def safe_csv_read(path: str):
    try:
        df = pd.read_csv(path)
        yield df
    except FileNotFoundError:
        print(f"File not found: {path}")
        yield pd.DataFrame()  # empty fallback
    except pd.errors.ParserError:
        print(f"Invalid CSV format: {path}")
        yield pd.DataFrame()
    finally:
        print(f"Finished reading {path}")

with safe_csv_read('data.csv') as df:
    cleaned = df.dropna().groupby('category').sum()
    print(cleaned.head())

Best practices make error handling safe, readable, and performant. Catch specific exceptions — never bare except: or broad except Exception: unless logging/re-raising. Use else for success-only code — avoids confusing control flow. Always use finally or context managers for cleanup — files, connections, locks. Modern tip: use Polars for robust I/O — pl.read_csv(..., try_parse_dates=True) with try/except for graceful failures. Add type hints — def func() -> int: — reduces type-related exceptions. Log exceptions properly — use logging.exception() to capture traceback. Raise custom exceptions for domain errors — subclass ValueError or RuntimeError. Use contextlib.suppress() for ignoring specific exceptions cleanly. Use raise ... from None to suppress chained tracebacks when re-raising. Use assert for programmer errors (not user input) — fail fast in development. Combine with typing.NoReturn for functions that always raise. Test error paths — use pytest.raises() to verify exceptions. Use tenacity or backoff for retrying transient errors (network, rate limits).

Handling errors with try/except/else/finally makes code resilient — catch specific exceptions, recover where possible, clean up always, log meaningfully. In 2026, prefer specific catches, context managers, logging, custom exceptions, type hints, and Polars for robust I/O. Master error handling, and you’ll write reliable, debuggable, production-ready Python code that fails gracefully and recovers intelligently.

Next time an exception might occur — wrap it properly. It’s Python’s cleanest way to say: “Try this, catch problems, clean up, and keep going.”

Generating content...