Lección 26 de 47 · Herencia, protocolos y genéricos✦ WebMCP implementado
Duck typing, Protocol y ABC: interfaces sin implements
10 min de lectura4 retos
En PHP, para que dos clases se puedan usar en el mismo sitio, las haces implements de una misma interface. En Python no hace falta: si un objeto sabe hacer lo que se le pide, vale. A eso se le llama duck typing. Y cuando quieres dejar escrito qué se espera, usas un Protocol, que es una interface que las clases cumplen sin declararlo.
Viene de la frase «si camina como un pato y hace cuac como un pato, entonces es un pato». No importa qué clase es el objeto, importa qué sabe hacer.
Protocol = inglés protocol (protocolo: las reglas de cómo se habla)
Un conjunto de métodos que un objeto debe tener. Está en el módulo typing y es parecido a una interface de PHP.
typing = inglés typing (tipado)
El módulo de la biblioteca estándar con las herramientas para escribir los tipos: Protocol, Callable, final...
runtime_checkable = inglés runtime (tiempo de ejecución) + checkable (comprobable)
Un decorador que deja usar isinstance() con un Protocol. Sin él, solo lo miran las herramientas de tipos.
En 4 ideas
1/4
Duck typing: a una función le da igual la clase del objeto; solo le importa que tenga el método que va a llamar. En PHP exigirías implements Notificador en el parámetro.
Si el objeto no sabe hacer lo que se le pide, el fallo (AttributeError) sale al llamar, no al pasarlo. PHP lo cazaría antes con el tipo del parámetro.
typing.Protocol es una interfaceestructural: una clase la cumple si tiene los métodos, sin escribir implements. PHP es nominal: hay que nombrar la interfaz.
Los type hints son anotaciones: Python no las comprueba al ejecutar. Las vigilan herramientas aparte, como mypy o pyright (en PHP, declare(strict_types=1) sí las impone, y PHPStan ayuda con lo demás).
1 · Duck typing: si sabe hacerlo, vale
Imagina que buscas a alguien que te ayude a mover un sofá. No pides «un amigo, con carné de amigo». Pides a alguien que pueda cargar. Si viene tu primo, tu vecina o un robot, da igual: cargan. Eso es el duck typing.
Consola y Correo no se conocen, no heredan de nada común y no declaran ninguna interfaz. A avisar solo le importa una cosa: que tengan enviar. Así lo harías en PHP:
En PHP, el tipo del parámetro (Notificador $canal) se comprueba al llamar: si pasas algo que no es un Notificador, salta un TypeError. Para que una clase de otra librería sirva, tienes que poder editarla y añadirle implements.
Python comprueba lo mínimo, en el momento de usar: cuando canal.enviar(...) se ejecuta, o existe o no existe. Así sirve cualquier clase, incluso una de una librería ajena que no puedes tocar, y los tests pueden pasar un objeto falso de tres líneas sin crear ninguna interfaz.
El precio: el error no sale al pasar el objeto, sino al llamarlo. Para eso existen los Protocol y las herramientas de tipos (más abajo).
2 · Cuando el pato no es un pato
¿Y si pasas algo que no sabe enviar? Python no se queja al pasarlo; se queja cuando la función intenta usarlo. Mira la diferencia entre fallar «pronto» y fallar «tarde»:
Fíjate en que avisar empieza se imprime antes del fallo: si la función hubiera hecho cosas antes de llamar a enviar (guardar en base de datos, por ejemplo), esas cosas ya habrían pasado. Es el defecto del duck typing.
Hay dos formas de vivir con ello. En Python se conocen por unas siglas en inglés:
Estilo
Significa
Ejemplo
En PHP
EAFP
Easier to Ask Forgiveness than Permission: mejor pedir perdón que pedir permiso
try: canal.enviar(t) y capturar el error
try { ... } catch
LBYL
Look Before You Leap: mira antes de saltar
if hasattr(canal, "enviar"): ...
if (method_exists($canal, 'enviar'))
3 · Protocol: la interface sin implements
Aquí está la pieza de la app de tareas: el repositorio, el objeto que guarda y recupera tareas. Hoy los guardamos en memoria; en el módulo 10 serán una base de datos SQLite. Para que el resto del código no cambie, escribimos qué sabe hacer un repositorio con un Protocol:
Mira lo que no hay: RepositorioMemoria no dice en ningún sitio que cumple RepositorioTareas. Lo cumple porque tiene los cuatro métodos con esa forma. El ... del Protocol significa «aquí no hay cuerpo, solo la firma».
¿Por qué «estructural» y no «nominal»? La diferencia con interface
PHP es nominal: una clase cumple una interfaz si lo dice con su nombre (implements RepositorioTareas). Si olvidas el implements, no sirve, aunque tenga los cuatro métodos.
Python con Protocol es estructural: una clase cumple el protocolo si tiene la forma (los métodos con esas firmas). Es el duck typing, pero escrito y vigilable por mypy o pyright. Y tiene una ventaja grande: puedes definir el protocolo después, y en el lado de quien lo usa, sin tocar las clases que ya existen.
Pregunta
interface de PHP (nominal)
Protocol de Python (estructural)
¿Cómo se cumple?
Escribiendo implements X
Teniendo los métodos
¿Hay que editar la clase?
Sí, siempre
No: sirve una clase ya escrita por otros
¿Quién lo comprueba?
PHP, al llamar (TypeError)
mypy/pyright al analizar; Python, nunca
¿Cuándo usarlo?
Siempre que quieras un contrato
Cuando quieras documentar «lo que espero de un objeto»
4 · ¿ABC o Protocol? isinstance con protocolos
Ya tienes dos formas de dejar escrito un contrato: la clase abstracta (ABC, lección anterior) y el Protocol. No son lo mismo:
Característica
ABC + @abstractmethod
Protocol
Hay que heredar
Sí: class X(Notificador)
No
Puede traer código ya hecho
Sí (métodos normales)
Solo la firma (lo normal)
Falla al crear el objeto
Sí, si falta un método
No: Python no mira
Equivale en PHP a
abstract class
interface
Úsalo cuando
Quieres compartir código entre hijas
Quieres solo el contrato, sin atar a nadie
Si quieres que isinstance() funcione con un protocolo, hay que marcarlo con @runtime_checkable. Ojo con lo que comprueba:
Pythonmain.py
from typing importProtocol, runtime_checkable
@runtime_checkableclassNotificador(Protocol):
defenviar(self, texto: str) -> None: ...
classConsola:
defenviar(self, texto):
print(texto)
classMudo:
passclassRaro:
enviar = "no soy un metodo"print(isinstance(Consola(), Notificador))
print(isinstance(Mudo(), Notificador))
print(isinstance(Raro(), Notificador))
5 · Los type hints no se comprueban al ejecutar
Esto es lo que más cuesta aceptar viniendo de PHP con strict_types: en Python, def doble(n: int) -> intno obliga a nada. El : int es una nota para humanos y para herramientas. Mira:
Pythonmain.py
defdoble(n: int) -> int:
return n * 2print(doble(4))
print(doble("ab"))
print(doble.__annotations__)
¿Por qué? · En PHP no existe
¿Por qué Python no comprueba los tipos al ejecutar?
Python nació sin tipos y los añadió después, como anotaciones opcionales, para no romper el código de millones de personas. Comprobar cada llamada en ejecución además haría el programa más lento.
En su lugar, la comprobación se hace antes de ejecutar, con una herramienta aparte que lee tu código sin correrlo. Es lo que en PHP hace PHPStan o Psalm (cuando strict_types no basta). Pasa lo mismo con los Protocol: solo los vigila esa herramienta.
La pregunta que te vas a hacer
Vale, pero… ¿y cómo me avisa Python de un tipo mal puesto?
Instalas un comprobador de tipos y lo ejecutas como un paso más (igual que PHPStan en tu CI). Los dos más usados:
mypy: el comprobador clásico, en la línea de comandos: mypy main.py.
pyright: el de Microsoft, el que usa el editor VS Code (Pylance) mientras escribes.
El módulo typing: documentación oficial de Protocol, Callable, final...
Las interfaces de PHP traducidas a lo que has visto en esta lección:
PHP
Python
Quién lo ve
interface RepositorioTareas
class RepositorioTareas(Protocol)
Quien la use en un tipo
class X implements Y
(nada: basta con tener los métodos)
Lo comprueba mypy/pyright
instanceof Notificador
isinstance(x, Notificador) con @runtime_checkable
Solo mira que existan los nombres
abstract class con código compartido
class A(ABC) + @abstractmethod
Falla al crear el objeto
method_exists($x, 'enviar')
hasattr(x, "enviar") o try/except AttributeError
Cualquiera, en ejecución
tipo de parámetro Notificador $c (se impone)
canal: Notificador (solo anotación)
Python no lo comprueba al ejecutar
declare(strict_types=1)
(no existe: se usa mypy o pyright)
Un paso aparte, antes de ejecutar
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Un canal de correo
avisar funciona con cualquier objeto que tenga enviar. Escribe el método enviar(self, texto) de Correo para que imprima correo: seguido del texto. El programa debe imprimir consola: hola y correo: hola. En PHP exigirías implements Notificador; aquí basta con el método.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Cambia el texto de print en Correo.enviar para que use una f-string con correo: {texto}.
Reto 2 de 4 · ✓ Resuelto
Contar pendientes sin saber de qué repositorio hablas
Escribe total_pendientes(repo): recibe cualquier objeto con un método listar() (que devuelve tareas) y devuelve cuántas tienen hecha == False. Los tests le pasan un repositorio falso que no hereda de nada: es duck typing. En PHP serían un count(array_filter(...)).
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Recorre repo.listar() y cuenta las tareas con not t.hecha. No hace falta comprobar la clase de repo.
Reto 3 de 4 · ✓ Resuelto
Un Protocol de notificadores
Define Notificador(Protocol) con el método enviar(self, texto: str) -> bool (devuelve True si salió bien) y escribe avisar_todos(canales, texto), que llama a enviar en cada canal y devuelve cuántos devolvieron True. Es una interface de PHP más un count().
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.class Notificador(Protocol): con la firma y ... como cuerpo. Para contar, sum(1 for canal in canales if canal.enviar(texto)).
Reto 4 de 4 · ✓ Resuelto
El repositorio en memoria
Completa RepositorioMemoria para que cumpla RepositorioTareas: guardar (guarda por id y devuelve la tarea), buscar_por_id (lanza KeyError si no existe), listar (en orden de guardado) y borrar (lanza KeyError si no existe). Sin heredar de nada. Es tu RepositorioMemoria implements RepositorioTareas de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Un diccionario self._tareas hace casi todo: [id] lanza KeyError solo y del self._tareas[id] también. Para listar, list(self._tareas.values()).
Resumen
Lo que te llevas de esta lección
Duck typing: importa lo que el objeto sabe hacer, no su clase (en PHP exigirías implements).
Si falta el método, el AttributeError sale al llamarlo, no al pasarlo (PHP lo cazaría en el tipo del parámetro).
Protocol es una interfaceestructural: se cumple teniendo los métodos, sin implements. RepositorioTareas(Protocol) vale para memoria y para SQLite.
ABC para compartir código y obligar a heredar; Protocol para solo describir el contrato.
Los type hints no se comprueban al ejecutar: eso lo hace mypy/pyright, como PHPStan lo hace en PHP.
Para recordarlo: «Cuac, Contrato, Comprobador»
CCuac si sabe hacerlo, vale: duck typing
CContrato Protocol describe lo que esperas
CComprobador mypy/pyright, nunca Python
Tres C para no liarte: Cuac (basta con saber hacerlo), Contrato (el Protocol lo deja escrito) y Comprobador (quien lo vigila no es Python, es mypy). «Sin implements, pero con sentido».