我正在尝试在循环内创建函数：
functions = []
for i in range(3):
def f():
return i
# alternatively: f = lambda: i
functions.append(f)
print([f() for f in functions])
# expected output: [0, 1, 2]
# actual output: [2, 2, 2]
你遇到了一个关于延迟绑定的问题 -- 每个函数尽可能晚地查找变量i（因此，当在循环结束后调用时，i将被设为2）。
通过强制进行早期绑定来轻松解决：像这样将def f():更改为def f(i=i):：
def f(i=i):
return i
默认值（在i=i中右边的i是参数名i的默认值，而左边的i是函数定义中使用该参数的变量名）在定义函数时就会被查找，而不是在调用时，因此本质上它们是一种寻找早绑定的特殊方式。
如果你担心函数会得到额外的参数（从而可能被错误地调用），还有一种更复杂的方法，涉及使用闭包作为“函数工厂”：
def make_f(i):
def f():
return i
return f
在循环中使用 f = make_f(i) 而不是 def 语句。
问题在于在函数 f 创建时并未保存变量 i 的值。相反，f 在被调用时查找变量 i 的值。
如果你仔细思考，这种行为是很合理的。实际上，这是函数能够运作的唯一合理方式。想象一下，如果你有一个访问全局变量的函数，像这样：
global_var = 'foo'
def my_function():
print(global_var)
global_var = 'bar'
my_function()
i by using it as a default argumentUnlike closure variables (like i), default arguments are evaluated immediately when the function is defined:
for i in range(3):
def f(i=i): # <- right here is the important bit
return i
functions.append(f)
To give a little bit of insight into how/why this works: A function's default arguments are stored as an attribute of the function; thus the current value of i is snapshotted and saved.
>>> i = 0
>>> def f(i=i):
... pass
>>> f.__defaults__ # this is where the current value of i is stored
(0,)
>>> # assigning a new value to i has no effect on the function's default arguments
>>> i = 5
>>> f.__defaults__
(0,)
i in a closureThe root of your problem is that i is a variable that can change. We can work around this problem by creating another variable that is guaranteed to never change - and the easiest way to do this is a closure:
def f_factory(i):
def f():
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range(3):
f = f_factory(i)
functions.append(f)
functools.partial to bind the current value of i to ffunctools.partial lets you attach arguments to an existing function. In a way, it too is a kind of function factory.
import functools
def f(i):
return i
for i in range(3):
f_with_i = functools.partial(f, i) # important: use a different variable than "f"
functions.append(f_with_i)
注意：这些解决方案仅在您将新值分配给变量时才有效。如果您修改存储在变量中的对象，则会再次遇到相同的问题：
>>> i = [] # instead of an int, i is now a *mutable* object
>>> def f(i=i):
... print('i =', i)
...
>>> i.append(5) # instead of *assigning* a new value to i, we're *mutating* it
>>> f()
i = [5]
注意，即使我们将其变为默认参数，i仍然被改变了！如果您的代码会对i进行更改，那么您必须将i的副本绑定到函数中，如下所示：
def f(i=i.copy()):f = f_factory(i.copy())f_with_i = functools.partial(f, i.copy())f_factory都会创建一个新的堆栈帧和新的本地变量，每个闭包将单独使用它们。我们仍然可以在创建（但在返回）f之后在f_factory内修改i。 - Karl Knechtellambda的人来说：lambda: i替换为lambda i=i: i。functions = []
for i in range(3):
functions.append(lambda i=i: i)
print([f() for f in functions])
# [0, 1, 2]
nonlocal 实现：def f_factory(i):
def f(offset):
nonlocal i
i += offset
return i # i is now a *local* variable of f_factory and can't ever change
return f
for i in range(3):
f = f_factory(i)
print(f(10))
你必须将每个 i 值保存在内存中的单独空间中，例如：
class StaticValue:
val = None
def __init__(self, value: int):
StaticValue.val = value
@staticmethod
def get_lambda():
return lambda x: x*StaticValue.val
class NotStaticValue:
def __init__(self, value: int):
self.val = value
def get_lambda(self):
return lambda x: x*self.val
if __name__ == '__main__':
def foo():
return [lambda x: x*i for i in range(4)]
def bar():
return [StaticValue(i).get_lambda() for i in range(4)]
def foo_repaired():
return [NotStaticValue(i).get_lambda() for i in range(4)]
print([x(2) for x in foo()])
print([x(2) for x in bar()])
print([x(2) for x in foo_repaired()])
Result:
[6, 6, 6, 6]
[6, 6, 6, 6]
[0, 2, 4, 6]
l=[]
for t in range(10):
def up(y):
print(y)
l.append(up)
l[5]('printing in 5th function')
只需修改最后一行
functions.append(f())
f是一个函数——Python将函数视为一等公民，您可以将它们传递到变量中以便稍后调用。因此，您原始的代码所做的是将函数本身附加到列表中，而您想要做的是将函数的结果附加到列表中，这就是上面一行通过调用函数实现的内容。
lambda: i替换为lambda i=i: i。您的代码现在是for i in range(3): functions.append(lambda i=i: i)。 - Basjlambda: i替换为lambda i=i: i。您的代码现在是for i in range(3): functions.append(lambda i=i: i)。 - undefined