Cierres y Captura de Ámbito

Un cierre es una función que recuerda variables del ámbito circundante donde fue definida. Los cierres permiten fábricas, decoradores y callbacks, pero el enlace tardío en bucles es un error clásico.

Receta

def make_multiplier(factor: int):
    def multiply(value: int) -> int:
        return value * factor
    return multiply
 
double = make_multiplier(2)
print(double(10))  # 20

Cuándo usar esto:

• Funciones de fábrica con comportamiento configurado
• Decoradores que envuelven llamables
• Manejadores de eventos que capturan contexto
• Aplicación parcial sin functools.partial

Ejemplo de Trabajo

from typing import Callable
 
def make_counter(start: int = 0) -> Callable[[], int]:
    count = start
    def inc() -> int:
        nonlocal count
        count += 1
        return count
    return inc
 
def make_handlers_bad():
    return [lambda: i for i in range(3)]  # error de enlace tardío
 
def make_handlers_good():
    return [lambda i=i: i for i in range(3)]
 
def tracer(label: str):
    def decorate(fn):
        def wrapper(*args, **kwargs):
            print(f"{label}: enter")
            return fn(*args, **kwargs)
        return wrapper
    return decorate
 
@tracer("api")
def ping() -> str:
    return "pong"
 
if __name__ == "__main__":
    c = make_counter(10)
    print(c(), c())
    print([h() for h in make_handlers_bad()])
    print([h() for h in make_handlers_good()])
    print(ping())

Lo que esto demuestra:

• nonlocal muta count en la función circundante
• Enlace tardío: las lambdas comparten la variable i; todas ven el valor final sin el truco del argumento predeterminado
• El argumento predeterminado i=i captura el valor en el momento de la definición de la lambda
• La fábrica de decoradores tracer devuelve un decorador que cierra sobre label

Análisis Profundo

Cómo Funciona

• Variables libres - Nombres referenciados pero no definidos en la función interna.
• Objetos celda (Cell objects) - Variables del ámbito circundante almacenadas en celdas compartidas por los cierres.
• LEGB - La búsqueda interna comprueba local, circundante (enclosing), global, incorporado (builtin).
• Enlace tardío (Late binding) - El cierre busca la variable cuando se llama, no cuando se crea.
• nonlocal vs global - nonlocal enlaza el ámbito circundante más cercano; global el ámbito del módulo.

Patrones de Corrección para el Enlace Tardío

Notas de Python

def make():
    funcs = []
    for i in range(3):
        def f(i=i):
            return i
        funcs.append(f)
    return funcs

Errores Comunes

• Enlace tardío de lambda en bucle - Todos los manejadores devuelven el último índice. Corrección: Argumento predeterminado o fábrica.
• Cerrar sobre objeto mutable - Lista compartida mutada por todos los cierres. Corrección: Copiar por cierre o capturas inmutables.
• Mutación global accidental - La función interna asigna sin nonlocal crea una variable local. Corrección: nonlocal o global explícito.
• Retención de memoria - El cierre mantiene vivo todo el ámbito circundante. Corrección: Minimizar las variables capturadas.
• Confusión de variables de celda en depuración - Inspeccionar __closure__ del cierre cuando esté perplejo.

Alternativas

Preguntas Frecuentes

Relacionado

• Funciones, Argumentos y Ámbito - LEGB
• Escribir Decoradores - decoradores basados en cierres
• functools - alternativa partial
• Métodos de Clase vs Instancia vs Estáticos - objetos llamables

Versiones de Pila: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.