Composición y delegación
«Favorece la composición sobre la herencia» se repite como un dogma y casi nunca se explica. La razón es concreta: con herencia, la interfaz de tu clase incluye la de la base, para siempre. Con composición, expones exactamente los métodos que decidas, y puedes cambiarlos sin romper a nadie.
En una línea
Sección titulada «En una línea»Heredar es ser; componer es tener, y tener deja cambiar de opinión.
Tres formas de delegar
Sección titulada «Tres formas de delegar»Explícita, método a método:
from collections import deque
class Cola: def __init__(self): self._items = deque()
def push(self, x): self._items.append(x)
def pop(self): return self._items.popleft()
def __len__(self): return len(self._items)Es la más verbosa y la más honesta: la interfaz pública está escrita y se puede leer.
Con __getattr__, reenviando lo que no exista:
class Envoltorio: def __init__(self, obj): self._obj = obj
def __getattr__(self, nombre): return getattr(self._obj, nombre)Es la más corta y la más peligrosa: convierte el objeto envuelto en parte de tu API sin documentarlo.
Por herencia de una ABC (capítulo 04), cuando el contrato lo define la interfaz y no la implementación.
| Acceso | Directo | Delegado con __getattr__ |
|---|---|---|
Atributo obj.x |
15 ns | 94 ns (6.3×) |
Método obj.haz() |
29 ns | 124 ns (4.3×) |
medido en CPython 3.13
__getattr__ sólo se invoca cuando el atributo no existe, así que cada acceso falla primero en el diccionario, luego en la clase, y después llama a tu método. Seis veces el coste de un atributo normal, en el mejor caso.
Composición con interfaz explícita
Sección titulada «Composición con interfaz explícita»El patrón que sí escala es el adaptador: la clase compuesta define su propio contrato y traduce.
class RepositorioSQL: def __init__(self, conexion): self._db = conexion
def guardar(self, entidad): self._db.execute("INSERT ...", entidad.dict())
def buscar(self, id): ...La clase de arriba no expone execute, commit ni nada de la conexión: expone dos operaciones del dominio. Cambiar de base de datos es cambiar __init__.
La fachada: simplificar sin ocultar
Sección titulada «La fachada: simplificar sin ocultar»El tercer uso de la composición no es reutilizar, es reducir. Una fachada expone tres operaciones de dominio sobre un subsistema de veinte clases:
class Facturacion: def __init__(self, repo, impuestos, correo): self._repo, self._impuestos, self._correo = repo, impuestos, correo
def emitir(self, pedido): total = self._impuestos.calcular(pedido) factura = self._repo.guardar(pedido, total) self._correo.enviar(pedido.cliente, factura) return facturaEl llamador no sabe que hay tres colaboradores ni en qué orden se usan. Eso es lo que hace testeable la clase: en un test se le pasan tres dobles y se comprueba la secuencia.
La diferencia con el envoltorio del capítulo es la dirección: el envoltorio añade comportamiento a un objeto; la fachada coordina varios.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si la relación es genuinamente «es un». Un
Perroes unAnimal; envolverlo en unPerroQueTieneUnAnimales absurdo. - Si sólo envuelves para añadir un método, una función libre o un mixin es más simple.
- Si necesitas polimorfismo con
isinstance, la herencia (o una ABC) sigue siendo el mecanismo del lenguaje. - Si el objeto compuesto expone los mismos veinte métodos que el interno, probablemente no había composición: había herencia disfrazada.
Ejercicio
Sección titulada «Ejercicio»Tienes una clase ClienteAPI con quince métodos y quieres añadir caché a dos de ellos, registro de llamadas a todos y un método nuevo ping(). ¿Herencia, composición o decoradores? Razona el coste de cada opción.
Solución
Decoradores para la caché y el registro: son comportamiento transversal, se aplican a los dos métodos concretos y no cambian la jerarquía.
from functools import lru_cache
def registrar_llamada(f): def envoltorio(*args, **kwargs): print(f"-> {f.__name__}") return f(*args, **kwargs) return envoltorio
class ClienteAPI: @lru_cache(maxsize=128) def obtener_usuario(self, id): ...
@registrar_llamada def crear_pedido(self, datos): ...Composición sólo si necesitas que la clase envuelta sea intercambiable (un cliente real y uno falso en tests): un ClienteConCache que contiene un ClienteAPI y expone los dos métodos cacheados más ping().
Herencia sería la peor opción: arrastra los quince métodos a la subclase, acopla el ciclo de vida y complica el test.
El criterio: si el cambio es por método, decorador; si es por objeto completo, composición; si es por tipo, herencia.
Comprobación con datos de ejemplo:
cliente = ClienteAPI()cliente.obtener_usuario(1)cliente.obtener_usuario(1)cliente.obtener_usuario(2)info = ClienteAPI.obtener_usuario.cache_info()print("aciertos:", info.hits, "| fallos:", info.misses)cliente.crear_pedido({"item": "viga"})assert info.hits == 1, "la segunda llamada con el mismo id acierta"Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulos 11 y 14.
- Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 8.
- Mediciones: ejecutadas en CPython 3.13 para este capítulo.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Herencia, MRO y super(): la alternativa que esta desplaza.
- 06 · Atributos y
__slots__: por qué__getattr__cuesta lo que cuesta. - 04 · ABCs y Protocol: contratos sin herencia de implementación.