¿Qué capturan los cierres de función (lambda)?

Recientemente comencé a jugar con Python y encontré algo peculiar en la forma en que funcionan los cierres. Considere el siguiente código:

adders=[0,1,2,3]

for i in [0,1,2,3]:
   adders[i]=lambda a: i+a

print adders[1](3)

Construye una matriz simple de funciones que toman una sola entrada y devuelven esa entrada agregada por un número. Las funciones se construyen en forbucle donde el iterador ise extiende desde 0a 3. Para cada uno de estos números lambda, se crea una función que captura iy agrega a la entrada de la función. La última línea llama a la segunda lambdafunción con 3como parámetro. Para mi sorpresa, la salida fue 6.

Esperaba un 4. Mi razonamiento fue: en Python todo es un objeto y, por lo tanto, cada variable es un puntero esencial. Al crear los lambdacierres para i, esperaba que almacenara un puntero al objeto entero al que apunta actualmente i. Eso significa que cuando se le iasigna un nuevo objeto entero no debería afectar los cierres creados anteriormente. Lamentablemente, la inspección de la addersmatriz dentro de un depurador muestra que sí. Todas las lambdafunciones se refieren al último valor de i, 3, que se traduce en adders[1](3)regresar 6.

Lo que me hace preguntarme sobre lo siguiente:

• ¿Qué capturan exactamente los cierres?
• ¿Cuál es la forma más elegante de convencer a las lambdafunciones de capturar el valor actual de iuna manera que no se verá afectada cuando icambie su valor?

Su segunda pregunta ha sido respondida, pero en cuanto a la primera:

¿Qué captura exactamente el cierre?

El alcance en Python es dinámico y léxico. Un cierre siempre recordará el nombre y el alcance de la variable, no el objeto al que apunta. Como todas las funciones en su ejemplo se crean en el mismo ámbito y usan el mismo nombre de variable, siempre se refieren a la misma variable.

EDITAR: Con respecto a su otra pregunta sobre cómo superar esto, hay dos formas que vienen a la mente:

1. La forma más concisa, pero no estrictamente equivalente, es la recomendada por Adrien Plisson . Cree una lambda con un argumento adicional y establezca el valor predeterminado del argumento adicional para el objeto que desea conservar.

2. Un poco más detallado pero menos hacky sería crear un nuevo alcance cada vez que cree el lambda:

   >>> adders = [0,1,2,3]
   >>> for i in [0,1,2,3]:
   ...     adders[i] = (lambda b: lambda a: b + a)(i)
   ...     
   >>> adders[1](3)
   4
   >>> adders[2](3)
   5

   El alcance aquí se crea usando una nueva función (una lambda, para abreviar), que vincula su argumento y pasa el valor que desea vincular como argumento. Sin embargo, en el código real, lo más probable es que tenga una función ordinaria en lugar de la lambda para crear el nuevo ámbito:

   def createAdder(x):
       return lambda y: y + x
   adders = [createAdder(i) for i in range(4)]

Puede forzar la captura de una variable utilizando un argumento con un valor predeterminado:

>>> for i in [0,1,2,3]:
...    adders[i]=lambda a,i=i: i+a  # note the dummy parameter with a default value
...
>>> print( adders[1](3) )
4

la idea es declarar un parámetro (ingeniosamente nombrado i) y darle un valor predeterminado de la variable que desea capturar (el valor de i)

Para completar, otra respuesta a su segunda pregunta: podría usar parcial en el módulo functools .

Con la importación de agregar desde el operador como Chris Lutz propuso, el ejemplo se convierte en:

from functools import partial
from operator import add   # add(a, b) -- Same as a + b.

adders = [0,1,2,3]
for i in [0,1,2,3]:
   # store callable object with first argument given as (current) i
   adders[i] = partial(add, i) 

print adders[1](3)

Considere el siguiente código:

x = "foo"

def print_x():
    print x

x = "bar"

print_x() # Outputs "bar"

Creo que la mayoría de la gente no encontrará esto confuso en absoluto. Es el comportamiento esperado.

Entonces, ¿por qué la gente piensa que sería diferente cuando se realiza en un bucle? Sé que cometí ese error, pero no sé por qué. Es el bucle? O tal vez la lambda?

Después de todo, el bucle es solo una versión más corta de:

adders= [0,1,2,3]
i = 0
adders[i] = lambda a: i+a
i = 1
adders[i] = lambda a: i+a
i = 2
adders[i] = lambda a: i+a
i = 3
adders[i] = lambda a: i+a

En respuesta a su segunda pregunta, la forma más elegante de hacerlo sería utilizar una función que tome dos parámetros en lugar de una matriz:

add = lambda a, b: a + b
add(1, 3)

Sin embargo, usar lambda aquí es un poco tonto. Python nos proporciona el operatormódulo, que proporciona una interfaz funcional para los operadores básicos. El lambda anterior tiene una sobrecarga innecesaria solo para llamar al operador de adición:

from operator import add
add(1, 3)

Entiendo que estás jugando, tratando de explorar el lenguaje, pero no puedo imaginar una situación en la que usaría una variedad de funciones en las que la rareza de alcance de Python se interpondría en el camino.

Si lo desea, puede escribir una pequeña clase que use su sintaxis de indexación de matriz:

class Adders(object):
    def __getitem__(self, item):
        return lambda a: a + item

adders = Adders()
adders[1](3)

Aquí hay un nuevo ejemplo que resalta la estructura de datos y el contenido de un cierre, para ayudar a aclarar cuándo se "guarda" el contexto adjunto.

def make_funcs():
    i = 42
    my_str = "hi"

    f_one = lambda: i

    i += 1
    f_two = lambda: i+1

    f_three = lambda: my_str
    return f_one, f_two, f_three

f_1, f_2, f_3 = make_funcs()

¿Qué hay en un cierre?

>>> print f_1.func_closure, f_1.func_closure[0].cell_contents
(<cell at 0x106a99a28: int object at 0x7fbb20c11170>,) 43 

En particular, my_str no está en el cierre de f1.

¿Qué hay en el cierre de f2?

>>> print f_2.func_closure, f_2.func_closure[0].cell_contents
(<cell at 0x106a99a28: int object at 0x7fbb20c11170>,) 43

Observe (de las direcciones de memoria) que ambos cierres contienen los mismos objetos. Por lo tanto, puede comenzar a pensar en la función lambda como una referencia al alcance. Sin embargo, my_str no está en el cierre para f_1 o f_2, y yo no está en el cierre para f_3 (no se muestra), lo que sugiere que los objetos de cierre en sí mismos son objetos distintos.

¿Los objetos de cierre son el mismo objeto?

>>> print f_1.func_closure is f_2.func_closure
False