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

Puede forzar la captura de una variable usando 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 (inteligentemente llamado 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 hace en un bucle? Sé que yo mismo cometí ese error, pero no se por qué. Es el bucle? ¿O quizás el 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 hacer esto sería usar una función que toma 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 módulo operator, que proporciona una interfaz funcional para los operadores básicos. La lambda anterior tiene 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 un situación Usaría una serie de funciones donde la rareza del alcance de Python se interpondría en el camino.

Si lo desea, podría escribir una clase pequeña que use su sintaxis de indexación de matrices:

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 de cierre."

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 

Notablemente, 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 (desde las direcciones de memoria) que ambos cierres contienen los mismos objetos. Por lo tanto, puede iniciar para pensar que la función lambda tiene una referencia al ámbito. Sin embargo, my_str no es en el cierre para f_1 o f_2, y i no está en el cierre para f_3 (no se muestra), lo que sugiere que los objetos de cierre en sí son objetos distintos.

¿Son los objetos de cierre mismos el mismo objeto?

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