Python Difícil · Teoría
24 lecciones originales con ejemplos breves, puntos clave y referencias para profundizar.
El modelo de datos conecta sintaxis y operaciones con métodos especiales. type, identidad, valor y mutabilidad determinan cómo participa un objeto en el lenguaje.
class Caja:
def __init__(self, valor): self.valor = valor
def __repr__(self): return f"Caja({self.valor!r})"Un iterable personalizado implementa __iter__ y puede crear un iterador independiente con __next__; este conserva su estado y termina con StopIteration. Separar iterable e iterador permite recorridos simultáneos y reiniciables, mientras otros métodos como __len__ y __contains__ completan un protocolo coherente.
class CuentaAtras:
def __init__(self, inicio): self.inicio = inicio
def __iter__(self): return IteradorCuentaAtras(self.inicio)
class IteradorCuentaAtras:
def __init__(self, actual): self.actual = actual
def __iter__(self): return self
def __next__(self):
if self.actual == 0: raise StopIteration
self.actual -= 1
return self.actual + 1Un descriptor define __get__, __set__ o __delete__ y controla acceso a atributos desde la clase propietaria. Un descriptor de datos tiene prioridad sobre el diccionario de instancia.
class Positivo:
def __set_name__(self, owner, name): self.name = "_" + name
def __get__(self, obj, owner=None): return getattr(obj, self.name)
def __set__(self, obj, value):
if value <= 0: raise ValueError("debe ser positivo")
setattr(obj, self.name, value)El MRO linealiza una jerarquía respetando precedencia local y monotonía. Clase.mro() permite inspeccionar el orden usado para resolver atributos y super.
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print(D.mro())En una jerarquía cooperativa cada método consume sus argumentos y llama super para continuar por el MRO. Saltarse la cadena rompe combinaciones posteriores.
class Registro:
def guardar(self, dato): return [dato]
class Auditoria(Registro):
def guardar(self, dato): return ["audit", *super().guardar(dato)]ABC y @abstractmethod declaran operaciones obligatorias y evitan instanciar clases incompletas. También pueden proporcionar una implementación reutilizable.
from abc import ABC, abstractmethod
class Repositorio(ABC):
@abstractmethod
def obtener(self, id): ...typing.Protocol describe una interfaz por estructura para análisis estático. Una clase compatible no necesita heredar del protocolo.
from typing import Protocol
class Cerrable(Protocol):
def close(self) -> None: ...
def cerrar(recurso: Cerrable) -> None:
recurso.close()Los parámetros de tipo expresan relaciones entre valores. Los límites y restricciones documentan qué operaciones puede asumir una implementación.
class Pila[T]:
def __init__(self): self._datos: list[T] = []
def push(self, valor: T) -> None: self._datos.append(valor)
def pop(self) -> T: return self._datos.pop()Una función interna conserva celdas del ámbito envolvente. nonlocal reasigna la celda; capturar una variable de bucle sin fijarla produce late binding.
def multiplicador(factor):
def aplicar(valor):
return valor * factor
return aplicarUn decorador parametrizado añade una fábrica: la llamada exterior recibe configuración, devuelve el decorador y este devuelve el wrapper.
from functools import wraps
def repetir(veces):
def decorar(funcion):
@wraps(funcion)
def wrapper(*args, **kwargs):
return [funcion(*args, **kwargs) for _ in range(veces)]
return wrapper
return decorarsend entrega un valor al yield suspendido, throw inyecta una excepción y close provoca GeneratorExit. El primer avance debe usar next o send(None).
def acumulador():
total = 0
while True:
valor = yield total
if valor is not None:
total += valorUn context manager personalizado implementa __enter__ y __exit__ para adquirir, liberar y decidir si propaga una excepción. @contextmanager expresa el mismo contrato con un generador de un único yield, y ExitStack compone dinámicamente varios recursos.
class Recurso:
def __enter__(self):
print("abrir")
return self
def __exit__(self, exc_type, exc, traceback):
print("cerrar")
return Falseasync def crea funciones de coroutine. await suspende la coroutine actual hasta completar un awaitable sin bloquear activamente el hilo del event loop.
import asyncio
async def calcular():
await asyncio.sleep(0)
return 7
print(asyncio.run(calcular()))El event loop agenda callbacks y avanza Tasks cuando sus coroutines pueden continuar. create_task mantiene una referencia a una ejecución concurrente cooperativa.
import asyncio
async def paso(nombre):
await asyncio.sleep(0)
return nombre
async def main():
tarea = asyncio.create_task(paso("A"))
return await tareaasyncio.TaskGroup espera todas las tareas al salir. Si una falla, cancela las restantes y agrupa errores no relacionados con cancelación.
import asyncio
async def main():
async with asyncio.TaskGroup() as grupo:
uno = grupo.create_task(asyncio.sleep(0, result=1))
dos = grupo.create_task(asyncio.sleep(0, result=2))
return uno.result() + dos.result()Una excepción de una Task se conserva hasta observar su resultado o esperarla. Task.cancel solicita cancelación inyectando CancelledError en el siguiente punto de suspensión; la limpieza debe usar finally y normalmente volver a propagar la cancelación.
import asyncio
async def trabajo():
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
print("cancelada")
raise
finally:
print("limpieza")async for usa __aiter__ y __anext__; este devuelve un awaitable y termina con StopAsyncIteration. Un generador asíncrono combina async def con yield.
import asyncio
async def eventos():
for valor in range(3):
await asyncio.sleep(0)
yield valorasync with espera __aenter__ y __aexit__. @asynccontextmanager permite expresar adquisición y limpieza asíncronas con un generador.
from contextlib import asynccontextmanager
@asynccontextmanager
async def sesion():
try:
yield "activa"
finally:
passcopy.copy crea otro contenedor y comparte referencias internas. copy.deepcopy recorre el grafo con memo para preservar ciclos y evitar duplicar el mismo objeto varias veces.
from copy import copy, deepcopy
original = {"config": {"activo": True}}
superficial = copy(original)
profunda = deepcopy(original)Los objetos hashables deben mantener un hash estable y los objetos iguales deben compartir hash. Sobrescribir __eq__ suele desactivar __hash__ para evitar claves mutables incoherentes.
from dataclasses import dataclass
@dataclass(frozen=True)
class Clave:
id: int
print(hash(Clave(3)))import consulta sys.modules y usa finders y loaders descritos por ModuleSpec. Los imports relativos dependen del paquete, no de la carpeta de trabajo.
import importlib
modulo = importlib.import_module("json")
print(modulo.__spec__.name)Los patrones pueden desestructurar secuencias, mappings y clases. Las guardas se evalúan después de que el patrón capture nombres; el orden de casos es significativo.
def clasificar(valor):
match valor:
case {"tipo": "punto", "x": x, "y": y} if x == y:
return "diagonal"
case [primero, *resto]:
return primero, resto
case _:
return Nonefunctools.partial fija argumentos sin ejecutar todavía. singledispatch selecciona una implementación por el tipo del primer argumento en runtime.
from functools import partial, singledispatch
doble = partial(pow, exp=2)
@singledispatch
def describir(valor): return "objeto"
@describir.register
def _(valor: int): return "entero"@cache memoriza por argumentos hashables sin límite; @lru_cache puede acotar entradas. Sólo es correcto reutilizar resultados cuando la función es estable para esos argumentos.
from functools import lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
return n if n < 2 else fibonacci(n - 1) + fibonacci(n - 2)