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 30 de 47 · Errores y funciones ✦ WebMCP implementado

Closures y decoradores

10 min de lectura 4 retos

En Python una función es un valor más: la puedes guardar, pasar y devolver desde otra función. Con eso salen dos herramientas clave: los closures (funciones que se acuerdan de lo que había a su alrededor) y los decoradores (el @algo que ves sobre una def). Verás también la trampa más traicionera de los closures y por qué un decorador de Python no tiene nada que ver con un attribute de PHP.

¿De dónde vienen los nombres?

closure = inglés closure (clausura, cierre)
Una función que se cierra sobre las variables de fuera: se las lleva con ella aunque la función que las creó ya haya terminado. En PHP, una function () use ($x).
nonlocal = inglés non (no) + local
«Esta variable no es local, es de la función de fuera». Permite cambiarla; es el use (&$x) de PHP, con referencia.
decorador = del verbo decorar (adornar)
Una función que recibe otra función y la devuelve adornada con algo extra (un registro, un temporizador, una caché). Se aplica con @.
functools = inglés function + tools (herramientas)
El módulo con herramientas para trabajar con funciones: wraps, cache, partial…
wraps = inglés wrap (envolver)
Un decorador para decoradores: hace que la función envuelta conserve su nombre y su documentación.
En 4 ideas
1/4

Un closure es una función definida dentro de otra que recuerda las variables de fuera (en PHP, function () use ($x) { ... }). Para cambiar esa variable hay que declararla nonlocal.

1 · Closures: funciones que recuerdan

Imagina una mochila. Cuando una función sale de la función que la creó, se lleva en la mochila las variables que necesitaba. Eso es un closure.

Pythonmain.py
def crea_filtro(prioridad_minima):
    # En PHP: return fn(array $t) => $t["prioridad"] >= $prioridad_minima;
    def filtro(tarea):
        return tarea["prioridad"] >= prioridad_minima
    return filtro


urgentes = crea_filtro(3)
tareas = [
    {"titulo": "Comprar pan", "prioridad": 1},
    {"titulo": "Entregar informe", "prioridad": 3},
    {"titulo": "Llamar al banco", "prioridad": 2},
]

print([t["titulo"] for t in tareas if urgentes(t)])

crea_filtro(3) ya terminó, pero urgentes sigue sabiendo que la prioridad mínima era 3: la lleva en la mochila.

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

function creaFiltro(int $prioridadMinima): Closure
{
    return fn(array $tarea): bool => $tarea["prioridad"] >= $prioridadMinima;
}

$urgentes = creaFiltro(3);
$tareas = [
    ["titulo" => "Comprar pan", "prioridad" => 1],
    ["titulo" => "Entregar informe", "prioridad" => 3],
];

foreach ($tareas as $tarea) {
    if ($urgentes($tarea)) {
        echo $tarea["titulo"] . PHP_EOL;
    }
}
Pythonmain.py
def crea_filtro(prioridad_minima):
    def filtro(tarea):
        return tarea["prioridad"] >= prioridad_minima
    return filtro


urgentes = crea_filtro(3)
tareas = [
    {"titulo": "Comprar pan", "prioridad": 1},
    {"titulo": "Entregar informe", "prioridad": 3},
]

for tarea in tareas:
    if urgentes(tarea):
        print(tarea["titulo"])
AspectoPHPPython
Captura variables de fueraHay que listarlas: function () use ($x). Las fn flecha capturan solas, por valor.Automático: ve todas las variables de la función de fuera
Qué capturaEl valor de $x en ese momento (salvo use (&$x))La variable misma (lo que valga cuando se llame)
Cambiar la variable de fuerause (&$x)nonlocal x

¿Por qué? · En PHP no existe

¿Por qué Python captura la variable y no su valor? En PHP se copia el valor

En PHP, use ($x) hace una foto del valor de $x en el momento de crear la función. Si luego $x cambia fuera, la función sigue con la foto.

En Python no hay que listar nada: el closure guarda una referencia a la variable (la etiqueta, como viste en el módulo 04). Es más cómodo (no escribes use) y permite closures que ven los cambios, pero tiene un peligro: si la variable cambia después, tu función se entera. Es la trampa de la sección siguiente.

2 · nonlocal: cambiar la variable de fuera

Un closure puede leer la variable de fuera sin más. Pero si asigna a un nombre, Python cree que es una variable nueva y local. Para decirle «no, es la de fuera» usas nonlocal.

Pythonmain.py
def crea_contador(inicio=0):
    cuenta = inicio

    def siguiente():
        nonlocal cuenta
        cuenta += 1
        return cuenta

    return siguiente


ids = crea_contador()
print(ids(), ids(), ids())

otros = crea_contador(100)
print(otros(), ids())

Cada crea_contador() crea su propia mochila: ids y otros no comparten la cuenta. Sin la línea nonlocal cuenta, la tercera línea de siguiente fallaría con UnboundLocalError.

Pythonmain.py
def sin_nonlocal():
    cuenta = 0

    def siguiente():
        cuenta += 1
        return cuenta

    return siguiente


try:
    sin_nonlocal()()
except UnboundLocalError as error:
    print(error)

3 · La trampa: late binding en bucles

Esta es una de las trampas más famosas de Python. Quieres una lista de funciones, una por tarea. Escribes un bucle y una lambda:

Pythonmain.py
titulos = ["Comprar pan", "Llamar al banco", "Repasar Python"]

# En PHP: cada fn captura el valor de $titulo en ese momento.
saludos = []
for titulo in titulos:
    saludos.append(lambda: f"Recuerda: {titulo}")

print([saludo() for saludo in saludos])

Esperabas ver tres títulos distintos y salen tres veces el último. Las tres lambdas comparten la misma variable titulo, y cuando por fin las llamas el bucle ya terminó y titulo vale "Repasar Python".

¿Por qué? · En PHP no existe

¿Por qué pasa? En PHP no

El closure de Python no guarda el valor de titulo: guarda la etiqueta titulo. Y mira dónde está esa etiqueta cuando llamas a la función (late binding, «enlace tardío»), no cuando la creaste.

En PHP una fn copia el valor en el momento de crearla: por eso el mismo bucle daría tres títulos distintos. Python te lo pone un poco más difícil, a cambio de closures que ven los cambios de la variable.

Hay dos arreglos. 1. Valor por defecto: un argumento con valor por defecto se evalúa al crear la función, así que guarda una copia:

Pythonmain.py
titulos = ["Comprar pan", "Llamar al banco", "Repasar Python"]

saludos = []
for titulo in titulos:
    saludos.append(lambda titulo=titulo: f"Recuerda: {titulo}")

print([saludo() for saludo in saludos])

2. Una función que fabrica funciones (la más clara): cada llamada tiene su propia mochila, con su propia variable:

Pythonmain.py
def crea_saludo(titulo):
    return lambda: f"Recuerda: {titulo}"


titulos = ["Comprar pan", "Llamar al banco", "Repasar Python"]
saludos = [crea_saludo(titulo) for titulo in titulos]

print([saludo() for saludo in saludos])

4 · Decoradores: una función que envuelve otra

Un decorador es un papel de regalo para una función: recibe la función, la envuelve con algo extra (imprimir, medir, comprobar) y devuelve el paquete. La función original no cambia.

Pythonmain.py
def registra(funcion):
    def envoltorio(*args, **kwargs):
        print(f"llamo a {funcion.__name__}{args}")
        resultado = funcion(*args, **kwargs)
        print(f"{funcion.__name__} devolvió {resultado!r}")
        return resultado
    return envoltorio


@registra
def suma_prioridades(a, b):
    return a + b


suma_prioridades(2, 3)

El @registra encima de la def es solo azúcar de esto:

Pythonmain.py
def suma_prioridades(a, b):
    return a + b


suma_prioridades = registra(suma_prioridades)

El nombre suma_prioridades ya no apunta a la función original sino al envoltorio, que la llama dentro. Los *args y **kwargs (módulo 01) dejan que el envoltorio sirva para cualquier función, tenga los parámetros que tenga.

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

function registra(callable $funcion): Closure
{
    return function (mixed ...$args) use ($funcion): mixed {
        echo "llamo a la función" . PHP_EOL;
        $resultado = $funcion(...$args);
        echo "devolvió $resultado" . PHP_EOL;
        return $resultado;
    };
}

$sumaPrioridades = registra(fn(int $a, int $b): int => $a + $b);
$sumaPrioridades(2, 3);
Pythonmain.py
def registra(funcion):
    def envoltorio(*args, **kwargs):
        print("llamo a la función")
        resultado = funcion(*args, **kwargs)
        print(f"devolvió {resultado}")
        return resultado
    return envoltorio


@registra
def suma_prioridades(a, b):
    return a + b


suma_prioridades(2, 3)

¿Por qué? · En PHP no existe

¿Por qué @decorador? ¿No son los attributes #[...] de PHP?

No. Un attribute de PHP (#[Route("/tareas")]) es solo una etiqueta con datos: no ejecuta nada. Otro código (un framework, con reflexión) tiene que leerla y actuar.

Un decorador de Python sí ejecuta código en el momento: sustituye la función por otra. En PHP se hace a mano (como en el ejemplo de arriba, con registra(...)) o con un patrón decorator de clases.

Sirve para lo que se repite en muchas funciones: registrar llamadas, medir tiempos, reintentar, comprobar permisos. Lo escribes una vez y lo pones con @ donde haga falta.

5 · functools.wraps: no pierdas el nombre

Hay un detalle feo. Tras decorar, la función ya no es la original: es el envoltorio, y ha perdido su nombre y su documentación.

Pythonmain.py
def registra(funcion):
    def envoltorio(*args, **kwargs):
        return funcion(*args, **kwargs)
    return envoltorio


@registra
def suma_prioridades(a, b):
    """Suma dos prioridades."""
    return a + b


print(suma_prioridades.__name__)
print(suma_prioridades.__doc__)

Debería decir suma_prioridades y su frase. Se arregla con functools.wraps, que copia esos datos al envoltorio:

Pythonmain.py
from functools import wraps


def registra(funcion):
    @wraps(funcion)
    def envoltorio(*args, **kwargs):
        return funcion(*args, **kwargs)
    return envoltorio


@registra
def suma_prioridades(a, b):
    """Suma dos prioridades."""
    return a + b


print(suma_prioridades.__name__)
print(suma_prioridades.__doc__)

6 · Decoradores con argumentos y functools.cache

Si quieres @repetir(3) con un número, hace falta un nivel más: repetir(3) devuelve el decorador, y el decorador envuelve la función. Son tres funciones anidadas:

Pythonmain.py
from functools import wraps


def repetir(veces):
    def decorador(funcion):
        @wraps(funcion)
        def envoltorio(*args, **kwargs):
            resultado = None
            for _ in range(veces):
                resultado = funcion(*args, **kwargs)
            return resultado
        return envoltorio
    return decorador


@repetir(3)
def avisa(titulo):
    print(f"Aviso: {titulo}")


avisa("Entregar informe")
  1. repetir(3) se ejecuta primero y devuelve decorador.
  2. @ aplica ese decorador a la función avisa.
  3. El resultado, envoltorio, es lo que queda con el nombre avisa.

Python trae decoradores ya hechos. El más útil es functools.cache: memoriza el resultado de cada llamada. Si repites los mismos argumentos, no recalcula.

Pythonmain.py
from functools import cache

llamadas = 0


@cache
def coste(prioridad):
    global llamadas
    llamadas += 1
    return prioridad * 10


print(coste(2), coste(2), coste(2), coste(5))
print("veces que se calculó:", llamadas)
print(coste.cache_info())

Se calculó solo dos veces (una por cada valor distinto) aunque llamaste cuatro. Es un static $cache = [] de PHP, pero sin escribirlo.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Contador de tareas

Escribe crea_contador(inicio=0): devuelve una función que, cada vez que la llamas, suma 1 y devuelve el nuevo número. Cada contador tiene su propia cuenta. Ejemplo: con c = crea_contador(10), c() da 11 y luego 12. Necesitas nonlocal.

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. Un closure se lleva las variables de fuera en la mochila (en PHP, use ($x), pero por valor); para cambiarlas, nonlocal (el use (&$x)).
  2. Late binding: un closure captura la variable, no su valor. Lambdas en un for dan todas el último valor; arréglalo con lambda x=x: o una función fábrica.
  3. @decorador encima de una def equivale a f = decorador(f); en PHP lo harías a mano y los #[attributes] no ejecutan nada.
  4. Todo envoltorio lleva @wraps(funcion) para conservar nombre y documentación.
  5. Un decorador con argumentos son tres funciones anidadas; @functools.cache memoriza resultados (el static $cache de PHP).

Para recordarlo: «Mochila, Envuelve, Conserva»

MMochila
el closure se lleva las variables de fuera
EEnvuelve
el decorador devuelve otra función
CConserva
@wraps guarda el nombre original

Closure = Mochila; decorador = papel de regalo que Envuelve; wraps = Conserva la etiqueta del regalo. Y la trampa: «en un bucle, cada función necesita su propia mochila».