列表推导中的 Lambda 函数[重复]

问题描述：

为什么以下两个列表推导的输出不同，即使f函数lambda相同？

f = lambda x: x*x
[f(x) for x in range(10)]

和

[lambda x: x*x for x in range(10)]

请注意，两者type(f)返回type(lambda x: x*x)相同的类型。

解决方案 1：

第一个创建一个 lambda 函数并调用它十次。

第二个不调用函数。它创建 10 个不同的 lambda 函数。它将所有这些函数放在一个列表中。要使其等同于第一个，您需要：

[(lambda x: x*x)(x) for x in range(10)]

或者更好的是：

[x*x for x in range(10)]

解决方案 2：

这个问题触及了“著名”和“明显”的 Python 语法中非常臭的部分 —— 什么优先，lambda，还是列表推导的 for。

我不认为 OP 的目的在于生成一个从 0 到 9 的方块列表。如果是这样的话，我们可以提供更多的解决方案：

squares = []
for x in range(10): squares.append(x*x)

• 这是命令式语法的传统用法。

但这不是重点。重点是为什么这种模棱两可的表达如此违反直觉？最后我有一个愚蠢的例子，所以不要太早否定我的回答（我在一次工作面试中就遇到过这种情况）。

因此，OP 的理解返回了 lambda 列表：

[(lambda x: x*x) for x in range(10)]

这当然只是平方函数的10 个不同副本，请参阅：

>>> [lambda x: x*x for _ in range(3)]
[<function <lambda> at 0x00000000023AD438>, <function <lambda> at 0x00000000023AD4A8>, <function <lambda> at 0x00000000023AD3C8>]

注意lambda 的内存地址 - 它们都是不同的！

你当然可以有这个表达式的更“最优” (哈哈) 版本：

>>> [lambda x: x*x] * 3
[<function <lambda> at 0x00000000023AD2E8>, <function <lambda> at 0x00000000023AD2E8>, <function <lambda> at 0x00000000023AD2E8>]

看到了吗？3 倍相同的lambda。

请注意，我使用了_变量。它与中for的没有任何关系（它在词汇上被掩盖了！）。明白了吗？x`lambda`

我不讨论为什么语法优先级不是这样的，这一切意味着：

[lambda x: (x*x for x in range(10))]

可以是：[[0, 1, 4, ..., 81]]，或[(0, 1, 4, ..., 81)]，或 ，我认为最合乎逻辑的是，这将是一个list1 元素 -generator返回值的 a 。事实并非如此，语言不是这样运作的。

但是如果……

如果您不掩盖for变量并在您的lambdas 中使用它，会怎么样？？？

好吧，然后糟糕的事情发生了。看看这个：

[lambda x: x * i for i in range(4)]

这当然意味着：

[(lambda x: x * i) for i in range(4)]

但这并不意味着：

[(lambda x: x * 0), (lambda x: x * 1), ... (lambda x: x * 3)]

这简直太疯狂了！

列表推导中的 lambda 是此推导范围内的闭包。这是一个词法闭包，因此它们引用ivia 引用，而不是求值时的值！

因此，这个表达式：

[(lambda x: x * i) for i in range(4)]

大致相当于：

[(lambda x: x * 3), (lambda x: x * 3), ... (lambda x: x * 3)]

我确信我们可以使用 Python 反编译器（例如dis模块）在这里看到更多内容，但对于 Python-VM 无关的讨论来说，这已经足够了。关于工作面试问题就说这么多。

现在，如何创建一个list乘法器 lambda，它实际上乘以连续整数？好吧，与接受的答案类似，我们需要i通过将其包装在另一个中来打破直接联系，该直接联系在列表理解表达式中lambda被调用：

前：

>>> a = [(lambda x: x * i) for i in (1, 2)]
>>> a[1](1)
2
>>> a[0](1)
2

后：

>>> a = [(lambda y: (lambda x: y * x))(i) for i in (1, 2)]
>>> a[1](1)
2
>>> a[0](1)
1

（我也有外部 lambda 变量 = i，但我认为这是更清晰的解决方案 - 我引入了它，y以便我们都能看到哪个是哪个）。

编辑2019-08-30：

按照 @josoler 的建议，@sheridp 的回答中也提到了这一点 - 列表理解“循环变量”的值可以“嵌入”到对象中 - 关键是要在正确的时间访问它。上面的“之后”部分通过将其包装在另一个中lambda并立即使用当前的值调用它来i实现。另一种方法（更容易阅读 - 它不会产生“WAT”效果）是将的值存储在对象i内部partial，并让“内部”（原始）lambda将其作为参数（由partial对象在调用时提供），即：

2 之后：

>>> from functools import partial
>>> a = [partial(lambda y, x: y * x, i) for i in (1, 2)]
>>> a[0](2), a[1](2)
(2, 4)

很好，但还有一点需要注意！假设我们想让代码阅读器更容易理解，并按名称传递因子（作为关键字参数partial）。让我们进行一些重命名：

2.5之后：

>>> a = [partial(lambda coef, x: coef * x, coef=i) for i in (1, 2)]
>>> a[0](1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: <lambda>() got multiple values for argument 'coef'

什么？

>>> a[0]()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() missing 1 required positional argument: 'x'

等一下...我们要将参数的数量改为 1，并且从“太多”变为“太少”？

嗯，它不是一个真正的 WAT，当我们以这种方式传递时coef，partial它会变成一个关键字参数，所以它必须位于位置x参数之后，如下所示：

3 之后：

>>> a = [partial(lambda x, coef: coef * x, coef=i) for i in (1, 2)]
>>> a[0](2), a[1](2)
(2, 4)

与嵌套的 lambda 相比，我更喜欢最后一个版本，但是每个人都有自己的想法……

编辑2020-08-18：

感谢评论者 dasWesen，我发现 Python 文档中涵盖了这些内容：https://docs.python.org/3.4/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result - 它处理的是循环而不是列表推导，但思想是一样的 - lambda 函数中的全局或非局部变量访问。甚至还有一个解决方案 - 使用默认参数值（就像任何函数一样）：

>>> a = [lambda x, coef=i: coef * x for i in (1, 2)]
>>> a[0](2), a[1](2)
(2, 4)

这样， coef 值就与函数定义时的 i 值绑定在一起了（参见 James Powell 的演讲“从上到下，从左到右”，这也解释了为什么可变的默认值被避免）。

解决方案 3：

最大的区别是第一个例子实际上调用了 lambda f(x)，而第二个例子却没有。

您的第一个例子相当于 ，[(lambda x: x*x)(x) for x in range(10)]而您的第二个例子相当于[f for x in range(10)]。

解决方案 4：

第一个

f = lambda x: x*x
[f(x) for x in range(10)]

f()对范围内的每个值运行，因此它对f(x)每个值都运行

第二个

[lambda x: x*x for x in range(10)]

对列表中的每个值运行 lambda，因此它会生成所有这些函数。

解决方案 5：

人们给出了很好的答案，但忘了提到我认为最重要的部分：在第二个例子中，X列表推导的 不同于函数X的lambda，它们完全不相关。因此，第二个例子实际上与以下相同：

[Lambda X: X*X for I in range(10)]

内部迭代range(10)仅负责在列表中创建 10 个类似的 lambda 函数（10 个独立但完全相似的函数 - 返回每个输入的 2 的幂）。

另一方面，第一个例子完全不同，因为迭代的 X 确实与结果交互，对于每次迭代，其值都是X*X如此，因此结果将是[0,1,4,9,16,25, 36, 49, 64 ,81]

解决方案 6：

其他答案都是正确的，但如果您尝试创建一个函数列表，每个函数都有不同的参数，可以稍后执行，则以下代码将执行此操作：

import functools
a = [functools.partial(lambda x: x*x, x) for x in range(10)]

b = []
for i in a:
    b.append(i())

In [26]: b
Out[26]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

虽然这个例子是人为的，但我发现当我想要一个函数列表，每个函数打印不同的内容时，它很有用，即

import functools
a = [functools.partial(lambda x: print(x), x) for x in range(10)]

for i in a:
    i()

解决方案 7：

您可以通过使用函数中的默认参数来解决第二个代码问题lambda。

>>> a = [lambda x=x: x*x for x in range(10)]
>>> for item in a:
>>>     print(item())
0
1
4
9
16
25
36
49
64
81