Python Error Handling Cheat Sheet

try:
    result = int(user_input)         # risky code
except ValueError as e:
    print(f'Invalid: {e}')           # recovery
    result = 0
else:
    print(f'Parsed: {result}')       # only if no exception
finally:
    print('Done')                    # always runs

try:
    value = int('abc')
except ValueError:
    value = 0
value   # => 0

# else keeps the try block minimal.
# Exceptions in else are NOT caught by the preceding except.
try:
    data = json.load(f)
except json.JSONDecodeError:
    data = {}
else:
    process(data)   # error here propagates normally

try:
    result = operation()
except (ValueError, TypeError) as e:
    print(f'Error: {e}')

try:
    with open('config.json') as f:
        config = json.load(f)
except FileNotFoundError:
    config = {}                      # missing file is OK
except json.JSONDecodeError as e:
    print(f'Malformed JSON: {e}')
    config = {}

# ValueError    — wrong value ('abc' to int)
# TypeError     — wrong type (1 + 'a')
# KeyError      — missing dict key
# IndexError    — list index out of range
# FileNotFoundError — file does not exist
# AttributeError   — missing attribute
# ZeroDivisionError — division by zero

# except Exception:      catches normal errors (recommended)
# except BaseException:   also catches KeyboardInterrupt, SystemExit
# except:                 same as BaseException (avoid!)

def validate_age(age):
    if age < 0:
        raise ValueError(f'Age cannot be negative: {age}')
    return age

try:
    process(data)
except Exception:
    logging.exception('Processing failed')
    raise   # re-raise the same exception

try:
    data = json.loads(raw)
except json.JSONDecodeError as e:
    raise ConfigError('Invalid config') from e
# Traceback shows: "The above exception was the direct cause..."

raise AppError('...') from None
# Hides the original exception (use sparingly)

class ConfigError(Exception):
    """Raised when configuration is invalid."""
    pass

raise ConfigError('Missing required field: name')

class AppError(Exception):
    """Base for all app errors."""
    pass

class NotFoundError(AppError):
    pass

class ValidationError(AppError):
    def __init__(self, field, message):
        self.field = field
        super().__init__(f'{field}: {message}')

try:
    load_config()
except AppError as e:
    # Catches NotFoundError, ValidationError, etc.
    print(f'App error: {e}')

try:
    user = db.get_user(user_id)
except DatabaseError as e:
    raise UserNotFoundError(f'User {user_id}') from e
# Traceback shows both exceptions with clear causal link

try:
    user = db.get_user(user_id)
except DatabaseError:
    raise UserNotFoundError(f'User {user_id}')
# Still chains via __context__, but message says:
# "During handling of the above exception, another exception occurred"

try:
    load_config()
except ConfigError as e:
    print(e.__cause__)     # explicit chain (from)
    print(e.__context__)   # implicit chain

with open('data.txt') as f:
    data = f.read()
# f.close() called automatically

import threading
lock = threading.Lock()
with lock:
    # critical section
    pass

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.elapsed = time.perf_counter() - self.start
        print(f'Elapsed: {self.elapsed:.4f}s')
        return False   # don't suppress exceptions

with Timer() as t:
    do_work()

from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    yield
    print(f'Elapsed: {time.perf_counter() - start:.4f}s')

with timer():
    do_work()

def process(items):
    assert len(items) > 0, 'items must not be empty'
    # ...

# Good: internal invariants / developer mistakes
assert isinstance(result, dict), f'Expected dict, got {type(result)}'

# Bad: user input validation (stripped with -O!)
# assert user_age > 0   # Don't do this!
if user_age <= 0:
    raise ValueError('Age must be positive')

# assert condition, "message"
# Raises AssertionError if condition is False
assert 0 < x < 100, f'x out of range: {x}'

int('abc')          # ValueError
1 + 'a'             # TypeError
len(42)             # TypeError

d = {'a': 1}
d['z']              # KeyError: 'z'
items = [1, 2]
items[5]            # IndexError: list index out of range

'hello'.foo         # AttributeError
print(undefined)    # NameError

open('missing.txt')       # FileNotFoundError
open('/etc/shadow')       # PermissionError
1 / 0                     # ZeroDivisionError

# BaseException
#   +-- SystemExit
#   +-- KeyboardInterrupt
#   +-- Exception
#       +-- ValueError
#       +-- TypeError
#       +-- LookupError
#       |   +-- KeyError
#       |   +-- IndexError
#       +-- OSError
#       |   +-- FileNotFoundError
#       |   +-- PermissionError
#       +-- RuntimeError
#       +-- StopIteration