BaseException
├── SystemExit
├── KeyboardInterrupt
├── GeneratorExit
└── Exception
    ├── ArithmeticError
    │   ├── ZeroDivisionError
    │   └── OverflowError
    ├── LookupError
    │   ├── IndexError
    │   └── KeyError
    ├── TypeError
    ├── ValueError
    ├── AttributeError
    ├── NameError
    ├── ImportError
    │   └── ModuleNotFoundError
    ├── OSError
    │   ├── FileNotFoundError
    │   ├── PermissionError
    │   └── TimeoutError
    ├── RuntimeError
    └── StopIteration

try:
    result = 10 / int(input("Divisor: "))
except ZeroDivisionError:
    print("Cannot divide by zero")
except ValueError:
    print("Invalid number entered")
except (TypeError, OverflowError) as e:
    print(f"Numeric error: {e}")
except Exception as e:
    print(f"Unexpected error: {type(e).__name__}: {e}")
else:
    print(f"Result: {result}")    # runs only if NO exception occurred
finally:
    print("Always runs — cleanup here")

import logging

def process_file(path: str):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError as e:
        logging.error(f"File missing: {path}")
        raise    # re-raise original exception, preserving traceback

    except PermissionError as e:
        raise RuntimeError(f"Cannot read {path}: permission denied") from e
        # 'from e' chains exceptions — shows both in traceback

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

class ValidationError(AppError):
    def __init__(self, field: str, message: str):
        self.field = field
        self.message = message
        super().__init__(f"Validation failed on '{field}': {message}")

class NotFoundError(AppError):
    def __init__(self, resource: str, id: int):
        super().__init__(f"{resource} with id={id} not found")
        self.resource = resource
        self.id = id

# Usage
try:
    raise ValidationError("email", "must contain @")
except ValidationError as e:
    print(e.field)    # "email"
    print(e)          # "Validation failed on 'email': must contain @"

# File — closed even if exception occurs
with open("data.txt", "r") as f:
    content = f.read()

# Multiple context managers
with open("input.txt") as fin, open("output.txt", "w") as fout:
    fout.write(fin.read().upper())

# Custom context manager using class
class TempDir:
    def __enter__(self):
        self.path = tempfile.mkdtemp()
        return self.path

    def __exit__(self, exc_type, exc_val, exc_tb):
        shutil.rmtree(self.path)
        return False   # False = do not suppress exceptions

# Custom context manager using contextlib
from contextlib import contextmanager

@contextmanager
def timer(label: str):
    import time
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.3f}s")

with timer("sort"):
    sorted(range(100_000), reverse=True)

# Raise multiple exceptions at once
raise ExceptionGroup("multiple errors", [
    ValueError("bad value"),
    TypeError("wrong type"),
    KeyError("missing key"),
])

# Handle specific types within the group
try:
    raise ExceptionGroup("errors", [ValueError("x"), TypeError("y")])
except* ValueError as eg:
    print(f"Value errors: {eg.exceptions}")
except* TypeError as eg:
    print(f"Type errors: {eg.exceptions}")

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("temp.txt")    # silently ignored if file doesn't exist

import time

def with_retry(func, retries=3, delay=1.0, exceptions=(Exception,)):
    for attempt in range(retries):
        try:
            return func()
        except exceptions as e:
            if attempt == retries - 1:
                raise
            time.sleep(delay * (2 ** attempt))   # exponential backoff

import logging
import traceback

def safe_run(func, *args, **kwargs):
    try:
        return func(*args, **kwargs)
    except Exception:
        logging.error("Unhandled exception", exc_info=True)
        # exc_info=True includes full traceback in log
        return None