Python Academy · Lección

Clausuras y variables libres

Capture el estado en funciones internas

Clausuras y variables libres es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Funciones anidadas

Python permite definir una función dentro de otra función. La función interna se crea de nuevo cada vez que se ejecuta la externa.

def outer():
    def inner():
        return 'from inner'
    return inner()
print(outer())

La función interna ve las variables externas

Una función interna puede leer las variables definidas en la función envolvente. Se denominan variables libres porque no son locales a la función interna.

def outer():
    message = 'hello'
    def inner():
        return message
    return inner()
print(outer())

¿Qué es una clausura?

Una clausura se produce cuando se devuelve una función interna que sigue recordando las variables libres de su ámbito envolvente, incluso después de que dicho ámbito haya terminado.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
g = make_greeter('Ada')
print(g())

El estado capturado persiste

La función externa ya ha terminado, pero la clausura conserva name. El valor permanece dentro de la función devuelta.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
a = make_greeter('Ada')
b = make_greeter('Bob')
print(a())
print(b())

Una fábrica de multiplicadores

Las clausuras son especialmente útiles como fábricas que producen funciones personalizadas. En este caso, cada función devuelta multiplica por un factor capturado.

def multiplier(factor):
    def multiply(n):
        return n * factor
    return multiply
double = multiplier(2)
triple = multiplier(3)
print(double(10))
print(triple(10))

Cada clausura es independiente

Cada llamada a la fábrica crea una clausura independiente con su propio valor capturado. No interfieren entre sí.

def adder(amount):
    def add(n):
        return n + amount
    return add
add5 = adder(5)
add100 = adder(100)
print(add5(1), add100(1))

Inspeccionar los valores capturados

Los nombres capturados se enumeran en __code__.co_freevars y sus valores se encuentran en las celdas de __closure__.

def make(x):
    def f():
        return x
    return f
fn = make(42)
print(fn.__code__.co_freevars)
print(fn.__closure__[0].cell_contents)

Las clausuras capturan variables, no valores

Una clausura captura la variable en sí, por lo que ve el valor final de la variable. Esto es importante cuando la variable cambia después de crear la clausura.

def build():
    x = 1
    def show():
        return x
    x = 99
    return show
print(build()())

La trampa del enlace tardío en bucles

Un problema clásico: todas las clausuras creadas en un bucle comparten la misma variable de bucle, por lo que capturan su último valor.

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])

Corregir el enlace tardío

Asigne el valor actual mediante un argumento predeterminado para que cada clausura capture su propia copia en el momento de la definición.

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)
print([f() for f in funcs])

Las clausuras como objetos ligeros

Una clausura combina datos y comportamiento, de forma muy parecida a un objeto pequeño; a menudo resulta más limpia que una clase completa para casos sencillos.

def counter_start(start):
    def value():
        return start
    return value
c = counter_start(10)
print(c())

Comprobación rápida

¿Qué es una clausura en Python?

Repaso: clausuras y variables libres

Ideas clave:

Las funciones internas pueden leer variables del ámbito envolvente (variables libres).
Una clausura es una función interna devuelta que recuerda esas variables.
Cada llamada a la fábrica crea una clausura independiente.
Las clausuras capturan variables, no valores, lo que provoca la trampa del enlace tardío en bucles; corríjala con un argumento predeterminado.

def power_of(exp):
    return lambda base: base ** exp
square = power_of(2)
print(square(9))

Preguntas frecuentes

¿La lección «Clausuras y variables libres» es gratis?

Sí — el texto completo de «Clausuras y variables libres» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Clausuras y variables libres»?

Capture el estado en funciones internas Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Clausuras y variables libres»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy