Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 26 de 47 · Herencia, protocolos y genéricos ✦ WebMCP implementado

Duck typing, Protocol y ABC: interfaces sin implements

10 min de lectura 4 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.

¿De dónde vienen los nombres?

duck typing = inglés duck (pato) + typing (tipado)
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.

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.

Pythonmain.py
class Consola:
    def enviar(self, texto):
        print(f"consola: {texto}")


class Correo:
    def __init__(self, direccion):
        self.direccion = direccion

    def enviar(self, texto):
        print(f"correo a {self.direccion}: {texto}")


def avisar(canal, texto):
    canal.enviar(texto)


avisar(Consola(), "Te quedan 3 tareas")
avisar(Correo("yo@example.com"), "Te quedan 3 tareas")

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:

PHP 8.5avisar.php
<?php
declare(strict_types=1);

interface Notificador
{
    public function enviar(string $texto): void;
}

class Consola implements Notificador
{
    public function enviar(string $texto): void
    {
        echo "consola: $texto" . PHP_EOL;
    }
}

class Correo implements Notificador
{
    public function __construct(private string $direccion) {}

    public function enviar(string $texto): void
    {
        echo "correo a {$this->direccion}: $texto" . PHP_EOL;
    }
}

function avisar(Notificador $canal, string $texto): void
{
    $canal->enviar($texto);
}

avisar(new Consola(), "Te quedan 3 tareas");
avisar(new Correo("yo@example.com"), "Te quedan 3 tareas");
Pythonmain.py
class Consola:
    def enviar(self, texto):
        print(f"consola: {texto}")


class Correo:
    def __init__(self, direccion):
        self.direccion = direccion

    def enviar(self, texto):
        print(f"correo a {self.direccion}: {texto}")


def avisar(canal, texto):
    canal.enviar(texto)


avisar(Consola(), "Te quedan 3 tareas")
avisar(Correo("yo@example.com"), "Te quedan 3 tareas")

¿Por qué? · En PHP no existe

¿Por qué Python no necesita implements?

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»:

Pythonmain.py
class Consola:
    def enviar(self, texto):
        print(f"consola: {texto}")


class Impresora:
    def imprimir(self, texto):
        print(f"imprimiendo: {texto}")


def avisar(canal, texto):
    print("avisar empieza")
    canal.enviar(texto)


avisar(Consola(), "hola")

try:
    avisar(Impresora(), "hola")
except AttributeError as error:
    print("AttributeError:", error)

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:

EstiloSignificaEjemploEn PHP
EAFPEasier to Ask Forgiveness than Permission: mejor pedir perdón que pedir permisotry: canal.enviar(t) y capturar el errortry { ... } catch
LBYLLook Before You Leap: mira antes de saltarif 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:

Pythonmain.py
from dataclasses import dataclass
from typing import Protocol


@dataclass
class Tarea:
    id: int
    titulo: str
    hecha: bool = False


class RepositorioTareas(Protocol):
    def guardar(self, tarea: Tarea) -> Tarea: ...
    def buscar_por_id(self, id: int) -> Tarea: ...
    def listar(self) -> list[Tarea]: ...
    def borrar(self, id: int) -> None: ...


class RepositorioMemoria:
    def __init__(self):
        self._tareas: dict[int, Tarea] = {}

    def guardar(self, tarea: Tarea) -> Tarea:
        self._tareas[tarea.id] = tarea
        return tarea

    def buscar_por_id(self, id: int) -> Tarea:
        return self._tareas[id]

    def listar(self) -> list[Tarea]:
        return list(self._tareas.values())

    def borrar(self, id: int) -> None:
        del self._tareas[id]


def completar(repo: RepositorioTareas, id: int) -> Tarea:
    tarea = repo.buscar_por_id(id)
    tarea.hecha = True
    return repo.guardar(tarea)


repo = RepositorioMemoria()
repo.guardar(Tarea(1, "Comprar pan"))
repo.guardar(Tarea(2, "Llamar al banco"))
completar(repo, 1)
print(repo.listar())

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

PHP 8.5RepositorioTareas.php
<?php
declare(strict_types=1);

final class Tarea
{
    public function __construct(
        public int $id,
        public string $titulo,
        public bool $hecha = false,
    ) {}
}

interface RepositorioTareas
{
    public function guardar(Tarea $tarea): Tarea;
    public function buscarPorId(int $id): Tarea;
    /** @return list<Tarea> */
    public function listar(): array;
    public function borrar(int $id): void;
}

final class RepositorioMemoria implements RepositorioTareas
{
    /** @var array<int, Tarea> */
    private array $tareas = [];

    public function guardar(Tarea $tarea): Tarea
    {
        $this->tareas[$tarea->id] = $tarea;
        return $tarea;
    }

    public function buscarPorId(int $id): Tarea
    {
        return $this->tareas[$id];
    }

    public function listar(): array
    {
        return array_values($this->tareas);
    }

    public function borrar(int $id): void
    {
        unset($this->tareas[$id]);
    }
}
Pythonmain.py
from dataclasses import dataclass
from typing import Protocol


@dataclass
class Tarea:
    id: int
    titulo: str
    hecha: bool = False


class RepositorioTareas(Protocol):
    def guardar(self, tarea: Tarea) -> Tarea: ...
    def buscar_por_id(self, id: int) -> Tarea: ...
    def listar(self) -> list[Tarea]: ...
    def borrar(self, id: int) -> None: ...


class RepositorioMemoria:
    def __init__(self):
        self._tareas: dict[int, Tarea] = {}

    def guardar(self, tarea: Tarea) -> Tarea:
        self._tareas[tarea.id] = tarea
        return tarea

    def buscar_por_id(self, id: int) -> Tarea:
        return self._tareas[id]

    def listar(self) -> list[Tarea]:
        return list(self._tareas.values())

    def borrar(self, id: int) -> None:
        del self._tareas[id]


repo = RepositorioMemoria()
repo.guardar(Tarea(1, "Comprar pan"))
print(repo.listar())

¿Por qué? · En PHP no existe

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

Preguntainterface de PHP (nominal)Protocol de Python (estructural)
¿Cómo se cumple?Escribiendo implements XTeniendo los métodos
¿Hay que editar la clase?Sí, siempreNo: 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 contratoCuando 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ísticaABC + @abstractmethodProtocol
Hay que heredarSí: class X(Notificador)No
Puede traer código ya hechoSí (métodos normales)Solo la firma (lo normal)
Falla al crear el objetoSí, si falta un métodoNo: Python no mira
Equivale en PHP aabstract classinterface
Úsalo cuandoQuieres compartir código entre hijasQuieres 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 import Protocol, runtime_checkable


@runtime_checkable
class Notificador(Protocol):
    def enviar(self, texto: str) -> None: ...


class Consola:
    def enviar(self, texto):
        print(texto)


class Mudo:
    pass


class Raro:
    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) -> int no obliga a nada. El : int es una nota para humanos y para herramientas. Mira:

Pythonmain.py
def doble(n: int) -> int:
    return n * 2


print(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...
  • Especificación de los protocolos: las reglas exactas de qué cumple un Protocol.

Equivalencia POO · PHP → Python

Las interfaces de PHP traducidas a lo que has visto en esta lección:

PHPPythonQuién lo ve
interface RepositorioTareasclass RepositorioTareas(Protocol)Quien la use en un tipo
class X implements Y(nada: basta con tener los métodos)Lo comprueba mypy/pyright
instanceof Notificadorisinstance(x, Notificador) con @runtime_checkableSolo mira que existan los nombres
abstract class con código compartidoclass A(ABC) + @abstractmethodFalla al crear el objeto
method_exists($x, 'enviar')hasattr(x, "enviar") o try/except AttributeErrorCualquiera, 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

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

Resumen

Lo que te llevas de esta lección

  1. Duck typing: importa lo que el objeto sabe hacer, no su clase (en PHP exigirías implements).
  2. Si falta el método, el AttributeError sale al llamarlo, no al pasarlo (PHP lo cazaría en el tipo del parámetro).
  3. Protocol es una interface estructural: se cumple teniendo los métodos, sin implements. RepositorioTareas(Protocol) vale para memoria y para SQLite.
  4. ABC para compartir código y obligar a heredar; Protocol para solo describir el contrato.
  5. 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».