Saltearse al contenido

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.

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.

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 ** 2

Forma() 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 Sequence
Sequence.register(MiClase) # isinstance(mi, Sequence) → True
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.

Comprobar un tipo en runtime
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.

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.

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) # True

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

  • 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 TypedDict o una dataclass describen mejor la forma.
  • En código de rendimiento crítico, isinstance contra ABC o Protocol es caro; usa atributos (hasattr) sólo si el perfil lo justifica.

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_checkable
class 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.

  • 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.py y mediciones/03-09-11-llamada-tipos.py.
  • 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.