copyfrom contextlib import contextmanager
import time

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

# Uso
with timer('query'):
    results = db.fetch_all()

copyfrom dataclasses import dataclass, field
from typing import ClassVar

@dataclass(frozen=True)  # immutable + hashable
class Point:
    x: float
    y: float
    label: str = ''

@dataclass
class Config:
    host: str = 'localhost'
    port: int = 8080
    tags: list = field(default_factory=list)
    _count: ClassVar[int] = 0

points = {Point(0,0), Point(1,2)}  # frozen → set ok

copyfrom typing import TypeVar, Protocol
from collections.abc import Callable, Iterator

T = TypeVar('T')

def first(items: list[T], default: T | None = None) -> T | None:
    return items[0] if items else default

# Protocol: duck typing + type safety
class Drawable(Protocol):
    def draw(self) -> None: ...

def render(obj: Drawable) -> None:
    obj.draw()

# TypeAlias (3.10+)
Vector = list[float]
Matrix = list[Vector]

copyimport logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
    datefmt='%H:%M:%S'
)
logger = logging.getLogger(__name__)

logger.debug("Detalle interno")
logger.info("Usuario %s autenticado", username)
logger.warning("Retry %d/%d", attempt, max_retries)
logger.error("Falla en %s", endpoint, exc_info=True)

copy# Pipeline lazy sin cargar todo en memoria
def read_lines(path):
    with open(path) as f:
        yield from f

def parse(lines):
    for line in lines:
        yield line.strip().split(',')

def filter_valid(rows):
    yield from (r for r in rows if len(r) == 3)

# Componer: procesa una línea a la vez
pipeline = filter_valid(parse(read_lines('data.csv')))
for row in pipeline:
    process(row)

copyimport functools, time

def retry(times=3, delay=1):
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            for attempt in range(times):
                try:
                    return fn(*args, **kwargs)
                except Exception as e:
                    if attempt == times - 1: raise
                    time.sleep(delay * 2**attempt)
        return wrapper
    return decorator

@retry(times=3, delay=0.5)
def fetch_api(url): ...

copy# Star unpacking
first, *rest = [1, 2, 3, 4, 5]
*init, last  = [1, 2, 3, 4, 5]

# Swap sin variable temp
a, b = b, a

# Unpack nested
(x, y), z = (1, 2), 3

# Merge dicts
full = {**defaults, **user_config, **env_config}

# Pasar lista/dict como args
args = [1, 2, 3]
result = fn(*args, **{'key': 'val'})

copy# Python 3.10+ structural pattern matching
match command:
    case {"action": "move", "dir": direction}:
        move(direction)
    case {"action": "attack", "target": t} if t in enemies:
        attack(t)
    case [x, y]:           # lista de 2 elementos
        draw(x, y)
    case Point(x=0, y=0):  # class pattern
        print("origin")
    case _:                # default
        print("unknown")

copy# ❌ Pyramid of doom
def process(user, data):
    if user:
        if user.is_active:
            if data:
                if validate(data):
                    return save(user, data)

# ✅ Early returns
def process(user, data):
    if not user:           return None
    if not user.is_active: raise ValueError("Inactive")
    if not data:           return None
    if not validate(data): raise ValueError("Invalid")
    return save(user, data)

copy# Keyword-only args (después del *)
def create_user(name, email, *, role='user', notify=True):
    ...

# Llamada explícita — sin ambigüedad posicional
create_user('Ana', 'ana@x.com', role='admin', notify=False)

copy# Variables: snake_case, descriptivos
user_count = 42           # no: uc, x, temp
is_authenticated = True   # bool: is_/has_/can_
MAX_RETRIES = 3           # constante: UPPER_CASE

# Prefijos especiales
_internal = 'privado módulo'
__dunder__ = 'protocolo Python'
_ = 'valor descartado'

# Funciones: verbo + sustantivo
get_user_by_id()
calculate_total_price()
is_valid_email()       # retorna bool
has_permission(user, 'admin')

copyimport pytest
from unittest.mock import patch, MagicMock

# Parametrize — múltiples casos, un test
@pytest.mark.parametrize("inp,expected", [
    ("hello", "HELLO"),
    ("", ""),
    ("123", "123"),
])
def test_uppercase(inp, expected):
    assert to_upper(inp) == expected

# Mock de dependencia externa
@patch('mymodule.requests.get')
def test_fetch(mock_get):
    mock_get.return_value.json.return_value = {'id': 1}
    result = fetch_user(1)
    assert result['id'] == 1

copy# ❌ O(n) lookup por iteración
valid = [x for x in data if x in allowed_list]

# ✅ O(1) con set
allowed_set = set(allowed_list)
valid = [x for x in data if x in allowed_set]

# ✅ String join eficiente
result = ''.join(str(x) for x in items)

copyimport os
from dataclasses import dataclass

@dataclass
class Settings:
    # Opcional con default
    db_url: str  = os.environ.get('DATABASE_URL', 'sqlite:///dev.db')
    debug: bool  = os.environ.get('DEBUG', 'false').lower() == 'true'
    workers: int = int(os.environ.get('MAX_WORKERS', 4))
    # Requerida: KeyError si falta → falla rápido
    api_key: str = os.environ['API_KEY']

settings = Settings()  # Singleton global