¿Cómo funcionan los cierres léxicos?

Mientras investigaba un problema que tenía con los cierres léxicos en el código Javascript, encontré este problema en Python:

flist = []

for i in xrange(3):
    def func(x): return x * i
    flist.append(func)

for f in flist:
    print f(2)

Tenga en cuenta que este ejemplo evita cuidadosamente lambda. Imprime "4 4 4", lo cual es sorprendente. Yo esperaría "0 2 4".

Este código Perl equivalente lo hace bien:

my @flist = ();

foreach my $i (0 .. 2)
{
    push(@flist, sub {$i * $_[0]});
}

foreach my $f (@flist)
{
    print $f->(2), "\n";
}

Se imprime "0 2 4".

¿Puedes por favor explicar la diferencia?

Actualizar:

El problema no es con iser global. Esto muestra el mismo comportamiento:

flist = []

def outer():
    for i in xrange(3):
        def inner(x): return x * i
        flist.append(inner)

outer()
#~ print i   # commented because it causes an error

for f in flist:
    print f(2)

Como muestra la línea comentada, ise desconoce en ese momento. Aún así, imprime "4 4 4".

Python se está comportando realmente como se define. Se crean tres funciones separadas , pero cada una tiene el cierre del entorno en el que están definidas , en este caso, el entorno global (o el entorno de la función externa si el bucle se coloca dentro de otra función). Sin embargo, este es exactamente el problema: en este entorno, estoy mutado y todos los cierres se refieren al mismo i .

Aquí es la mejor solución que puedo llegar a - crear un creater función e invocar que su lugar. Esto forzará diferentes entornos para cada una de las funciones creadas, con una i diferente en cada una.

flist = []

for i in xrange(3):
    def funcC(j):
        def func(x): return x * j
        return func
    flist.append(funcC(i))

for f in flist:
    print f(2)

Esto es lo que sucede cuando mezclas efectos secundarios y programación funcional.

Las funciones definidas en el bucle siguen accediendo a la misma variable imientras cambia su valor. Al final del ciclo, todas las funciones apuntan a la misma variable, que contiene el último valor en el ciclo: el efecto es el que se informa en el ejemplo.

Para evaluar iy usar su valor, un patrón común es establecerlo como un parámetro predeterminado: los valores predeterminados de los parámetros se evalúan cuando defse ejecuta la instrucción y, por lo tanto, el valor de la variable de bucle se congela.

Lo siguiente funciona como se esperaba:

flist = []

for i in xrange(3):
    def func(x, i=i): # the *value* of i is copied in func() environment
        return x * i
    flist.append(func)

for f in flist:
    print f(2)

Así es como lo hace usando la functoolsbiblioteca (que no estoy seguro de que estuviera disponible en el momento en que se planteó la pregunta).

from functools import partial

flist = []

def func(i, x): return x * i

for i in xrange(3):
    flist.append(partial(func, i))

for f in flist:
    print f(2)

Salidas 0 2 4, como se esperaba.

mira este:

for f in flist:
    print f.func_closure


(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)

Significa que todos apuntan a la misma instancia de variable i, que tendrá un valor de 2 una vez que finalice el ciclo.

Una solución legible:

for i in xrange(3):
        def ffunc(i):
            def func(x): return x * i
            return func
        flist.append(ffunc(i))

Lo que sucede es que la variable i se captura y las funciones devuelven el valor al que está vinculada en el momento en que se llama. En lenguajes funcionales, este tipo de situación nunca surge, ya que no sería un rebote. Sin embargo, con python, y también como has visto con lisp, esto ya no es cierto.

La diferencia con su ejemplo de esquema tiene que ver con la semántica del bucle do. Scheme está creando efectivamente una nueva variable i cada vez a través del ciclo, en lugar de reutilizar un enlace i existente como con los otros idiomas. Si usa una variable diferente creada externamente al bucle y la muta, verá el mismo comportamiento en el esquema. Intente reemplazar su bucle con:

(let ((ii 1)) (
  (do ((i 1 (+ 1 i)))
      ((>= i 4))
    (set! flist 
      (cons (lambda (x) (* ii x)) flist))
    (set! ii i))
))

Echa un vistazo aquí para más discusión sobre esto.

[Editar] Posiblemente una mejor manera de describirlo es pensar en el bucle do como una macro que realiza los siguientes pasos:

1. Defina una lambda que tome un solo parámetro (i), con un cuerpo definido por el cuerpo del bucle,
2. Una llamada inmediata de esa lambda con los valores apropiados de i como parámetro.

es decir. el equivalente a la siguiente pitón:

flist = []

def loop_body(i):      # extract body of the for loop to function
    def func(x): return x*i
    flist.append(func)

map(loop_body, xrange(3))  # for i in xrange(3): body

El i ya no es el del ámbito principal, sino una variable completamente nueva en su propio ámbito (es decir, el parámetro de la lambda) y así obtiene el comportamiento que observa. Python no tiene este nuevo alcance implícito, por lo que el cuerpo del bucle for solo comparte la variable i.

Todavía no estoy completamente convencido de por qué en algunos idiomas esto funciona de una manera y de otra. En Common Lisp es como Python:

(defvar *flist* '())

(dotimes (i 3 t)
  (setf *flist* 
    (cons (lambda (x) (* x i)) *flist*)))

(dolist (f *flist*)  
  (format t "~a~%" (funcall f 2)))

Imprime "6 6 6" (tenga en cuenta que aquí la lista es del 1 al 3, y está construida al revés "). Mientras que en Scheme funciona como en Perl:

(define flist '())

(do ((i 1 (+ 1 i)))
    ((>= i 4))
  (set! flist 
    (cons (lambda (x) (* i x)) flist)))

(map 
  (lambda (f)
    (printf "~a~%" (f 2)))
  flist)

Impresiones "6 4 2"

Y como ya he mencionado, Javascript está en el campo Python / CL. Parece que hay una decisión de implementación aquí, que diferentes lenguajes se acercan de distintas maneras. Me encantaría entender cuál es la decisión, exactamente.

El problema es que todas las funciones locales se unen al mismo entorno y, por lo tanto, a la misma ivariable. La solución (solución alternativa) es crear entornos separados (marcos de pila) para cada función (o lambda):

t = [ (lambda x: lambda y : x*y)(x) for x in range(5)]

>>> t[1](2)
2
>>> t[2](2)
4

La variable ies global, cuyo valor es 2 cada vez que fse llama a la función .

Me inclinaría a implementar el comportamiento que busca de la siguiente manera:

>>> class f:
...  def __init__(self, multiplier): self.multiplier = multiplier
...  def __call__(self, multiplicand): return self.multiplier*multiplicand
... 
>>> flist = [f(i) for i in range(3)]
>>> [g(2) for g in flist]
[0, 2, 4]

Respuesta a su actualización : No es la globalidad i per se lo que está causando este comportamiento, es el hecho de que es una variable de un alcance que tiene un valor fijo en los momentos en que se llama f. En su segundo ejemplo, el valor de ise toma del alcance de la kkkfunción, y nada cambia eso cuando se activan las funciones flist.

El razonamiento detrás del comportamiento ya se ha explicado, y se han publicado varias soluciones, pero creo que esta es la más pitónica (recuerde, ¡todo en Python es un objeto!):

flist = []

for i in xrange(3):
    def func(x): return x * func.i
    func.i=i
    flist.append(func)

for f in flist:
    print f(2)

La respuesta de Claudiu es bastante buena, usando un generador de funciones, pero la respuesta de piro es un truco, para ser honesto, ya que me está convirtiendo en un argumento "oculto" con un valor predeterminado (funcionará bien, pero no es "pitónico") .