Saltearse al contenido

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.

Heredar es ser; componer es tener, y tener deja cambiar de opinión.

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.

Un millón de accesos
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.

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__.

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 factura

El 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.

  • Si la relación es genuinamente «es un». Un Perro es un Animal; envolverlo en un PerroQueTieneUnAnimal es 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.

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"
  • 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.
  • 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.