Assume you use a for loop to define a few different lambdas (or even plain functions), e.g.:

squares = [] for x in range(5): Â Â Â Â squares.append(lambda: x**2)

This gives you a list that contains 5 lambdas that calculate x**2. You might expect that, when called, they

would return, respectively, 0, 1, 4, 9, and 16. However, when you actually try you will see that they all

return 16:

>>> squares[2]() 16 >>> squares[4]() 16

This happens because x is not local to the lambdas, but is defined in the outer scope, and it is accessed when

the lambda is called â€” not when it is defined. At the end of the loop, the value of x is 4, so all the functions

now return 4**2, i.e. 16. You can also verify this by changing the value of x and see how the results of the

lambdas change:

>>> x = 8 >>> squares[2]() 64

In order to avoid this, you need to save the values in variables local to the lambdas, so that they donâ€™t rely

on the value of the global x:

>>> squares = [] >>> for x in range(5): Â Â Â Â squares.append(lambda n=x: n**2)

Here, n=x creates a new variable n local to the lambda and computed when the lambda is defined so that

it has the same value that x had at that point in the loop. This means that the value of n will be 0 in the

first lambda, 1 in the second, 2 in the third, and so on. Therefore each lambda will now return the correct

result:

>>> squares[2]() 4 >>> squares[4]() 16

Note :that** this **behaviour** is not peculiar to lambdas, but applies to regular functions too.**