ABCs y Protocol
Un contrato dice qué métodos debe tener un objeto para usarse en un sitio. Python ofrece dos mecanismos incompatibles en la forma y complementarios en el uso: la clase base abstracta, que exige heredar, y el protocolo, que sólo exige parecerse. Elegir mal produce jerarquías forzadas o comprobaciones caras.
En una línea
Sección titulada «En una línea»La ABC dice «hereda de mí»; el Protocol dice «compórtate así». El primero es rápido y rígido, el segundo lento y flexible.
La clase base abstracta
Sección titulada «La clase base abstracta»from abc import ABC, abstractmethod
class Forma(ABC): @abstractmethod def area(self) -> float: ...
def describir(self) -> str: return f"{type(self).__name__} de {self.area():.2f}"
class Circulo(Forma): def __init__(self, r): self.r = r def area(self): return 3.14159 * self.r ** 2Forma() lanza TypeError: no se puede instanciar con métodos abstractos sin implementar. La ABC también puede aportar implementación (describir), que es lo que la distingue de una interfaz pura.
Y puede declarar subclases virtuales sin herencia:
from collections.abc import SequenceSequence.register(MiClase) # isinstance(mi, Sequence) → TrueEl protocolo
Sección titulada «El protocolo»from typing import Protocol
class Saludable(Protocol): def saludar(self) -> str: ...
def presentar(x: Saludable) -> str: return x.saludar()Cualquier objeto con saludar() sirve, sin heredar de nada. Es duck typing documentado y comprobable por mypy, que es lo que hace poderoso al patrón.
| Comprobación | Coste |
|---|---|
isinstance(x, ClaseConcreta) |
23 ns |
isinstance(x, ABC) |
153 ns (6.7×) |
isinstance(x, Protocol) con runtime_checkable |
255 ns (11×) |
python mediciones/04-01-04-poo.py y 03-09-11-llamada-tipos.py
Una ABC es más lenta que una clase concreta porque consulta el registro de subclases virtuales además de la jerarquía. Un Protocol es más lento todavía porque no comprueba herencia: recorre los atributos declarados y verifica que existan en el objeto.
Cuál elegir
Sección titulada «Cuál elegir»| Necesitas | Usa |
|---|---|
| Compartir implementación entre implementaciones | ABC |
| Registrar una clase externa como «de los míos» | ABC con register |
| Describir una forma sin imponer jerarquía | Protocol |
| Comprobar en runtime, barato | isinstance contra clase concreta |
Que mypy valide sin tocar el código del otro |
Protocol |
La biblioteca estándar usa las dos: collections.abc son ABCs, y typing define protocolos como Iterable, Sized o Callable.
Registrar lo que no puedes heredar
Sección titulada «Registrar lo que no puedes heredar»register permite declarar que una clase ajena cumple el contrato, sin tocarla:
from collections.abc import Sequence
class Rango: def __getitem__(self, i): ... def __len__(self): ...
Sequence.register(Rango)isinstance(Rango(), Sequence) # TrueEs lo que hace la biblioteca estándar con dict y Mapping, o con str y Sequence. Sirve para integrar código de terceros en tu jerarquía conceptual.
La advertencia: register no comprueba nada. Si registras una clase que no implementa los métodos, el isinstance mentirá y el fallo aparecerá al usarla. Es una promesa, no una verificación.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Con un solo consumidor. Si sólo hay una función que usa el objeto, no hace falta declarar el contrato: escríbelo en el docstring.
- Si ya hay una clase concreta clara. Abstraer por abstraer añade una capa que hay que mantener.
- Si el contrato es de datos y no de comportamiento. Un
TypedDicto unadataclassdescriben mejor la forma. - En código de rendimiento crítico,
isinstancecontra ABC o Protocol es caro; usa atributos (hasattr) sólo si el perfil lo justifica.
Ejercicio
Sección titulada «Ejercicio»Diseña el contrato de un «almacén de claves» que pueda implementarse con un diccionario en memoria, Redis y un archivo. ¿ABC o Protocol? ¿Qué métodos declara y cuáles deja fuera?
Solución
Protocol, porque las implementaciones no comparten código y una de ellas (Redis) podría venir de una librería externa que no puede heredar de tu clase.
from typing import Protocol, runtime_checkable
@runtime_checkableclass Almacen(Protocol): def obtener(self, clave: str) -> bytes | None: ... def guardar(self, clave: str, valor: bytes, ttl: int | None = None) -> None: ... def borrar(self, clave: str) -> None: ...Tres métodos, todos de dominio. Quedan fuera existe (se deduce de obtener), listar (no todas las implementaciones lo soportan igual) y cualquier método de conexión: son detalles de infraestructura.
runtime_checkable sólo si hay un punto del código que decida en ejecución; si no, se omite y el coste en runtime es cero. La ABC sería preferible si quisieras compartir la lógica de guardar_con_ttl entre las tres implementaciones.
Comprobación con datos de ejemplo:
class AlmacenMemoria: def __init__(self): self.datos = {}
def obtener(self, clave): return self.datos.get(clave)
def guardar(self, clave, valor, ttl=None): self.datos[clave] = valor
def borrar(self, clave): self.datos.pop(clave, None)
class NoEsAlmacen: def obtener(self, clave): return None
a = AlmacenMemoria()a.guardar("k", b"valor")print(a.obtener("k"), a.obtener("otra"))a.borrar("k")print(a.obtener("k"))print("cumple el protocolo:", isinstance(a, Almacen))print("no lo cumple:", isinstance(NoEsAlmacen(), Almacen))assert not isinstance(NoEsAlmacen(), Almacen), "faltan guardar y borrar"Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 13: Interfaces, Protocols, and ABCs.
- CPython 3.13:
Lib/abc.py,Lib/typing.py. - Mediciones:
mediciones/04-01-04-poo.pyymediciones/03-09-11-llamada-tipos.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Herencia, MRO y super(): la jerarquía que la ABC formaliza.
- 11 · Tipado que sirve (Parte III): el Protocol como anotación.
- 06 · Atributos y
__slots__: qué se comprueba exactamente cuando se busca un método.