Handling Python Exceptions and Warnings

Python
# Raise the most specific built-in exception that fits
def get_item(d, key):
    if key not in d:
        raise KeyError(f"{key!r} not found")
    return d[key]

# Chain exceptions to preserve context
try:
    get_item({}, "x")
except KeyError as e:
    raise RuntimeError("lookup failed") from e

# Emit a warning instead of failing hard
import warnings
def old_api():
    warnings.warn("old_api() is deprecated, use new_api()", DeprecationWarning, stacklevel=2)

Progress checklist for designing error handling:

• Identify the failure mode: programmer error, runtime/environment error, or a non-fatal condition
• Pick the narrowest matching built-in exception/warning class (see table below)
• If no built-in fits, define a custom exception inheriting from the closest built-in base
• Decide whether to chain (raise X from Y) or suppress (raise X from None) the causing exception
• Use try/except/else/finally correctly: else for success-only code, finally for cleanup
• For warnings, choose the right category and set stacklevel so the reported location is the caller's
• Configure warning filters only at the application entry point, not inside library code

Exception class selection

Warning category selection

Example 1: Wrapping a low-level error with context Input:

Python
def load_config(path):
    with open(path) as f:
        return parse(f.read())

Output:

Python
def load_config(path):
    try:
        with open(path) as f:
            return parse(f.read())
    except OSError as e:
        raise RuntimeError(f"could not load config from {path}") from e
    except ValueError as e:
        raise RuntimeError(f"config at {path} is malformed") from e

Example 2: Deprecating a function Input: def send(msg): ... needs to be replaced by send_message(msg). Output:

Python
import warnings

def send(msg):
    warnings.warn(
        "send() is deprecated since v2.0; use send_message() instead",
        DeprecationWarning,
        stacklevel=2,
    )
    return send_message(msg)

Example 3: Custom exception hierarchy Input: A library needs its own errors for a parsing module. Output:

Python
class ParserError(Exception):
    """Base class for all parser errors."""

class SyntaxParseError(ParserError):
    """Raised when input violates grammar rules."""

class EncodingParseError(ParserError, ValueError):
    """Raised when input encoding is invalid."""

Example 4: Suppressing exception chaining Input: Re-raising a domain error without leaking internal details. Output:

Python
try:
    _internal_lookup(key)
except _InternalKeyMiss:
    raise KeyError(key) from None