为什么 Python 的列表推导式不复制参数，这样实际对象就不会被改变？

Question

也许我已经喝了太多的函数式编程 Kool Aid，但是列表推导式的这种行为似乎是一个糟糕的设计选择：

>>> d = [1, 2, 3, 4, 5]
>>> [d.pop() for _ in range(len(d))]
[5, 4, 3, 2, 1]
>>> d
[]

为什么 d 不被复制，然后复制的词法范围版本不被复制突变（然后丢失）？列表理解的要点似乎应该是返回所需的列表，而不是返回列表并在幕后默默地改变一些其他对象。 d 的破坏有些隐式，这看起来不符合 Python 风格。这有一个好的用例吗？

为什么列表组合的行为与 for 循环完全相同，而不是更像函数（来自函数式语言，具有本地范围）？

Answer 1

Python 从不进行复制，除非你特别要求它进行复制。这是一个非常简单、清晰且完全可以理解的规则。给它添加例外和区别，例如“除非在列表推导式中出现以下情况……”，将是完全愚蠢的：如果Python的设计曾经由具有如此疯狂想法的人管理，那么Python将是一个病态的人，扭曲的，半残破的语言不值得学习。感谢您让我再次感到高兴，因为我意识到事实并非如此！

你想要一份副本吗？ 制作副本！当您更喜欢副本的开销时，这始终是Python中的解决方案，因为您需要执行一些不得反映在原始版本中的更改。也就是说，在一种干净方法中，

dcopy = list(d)
[dcopy.pop() for _ in range(len(d))]

如果您超级热衷于在单个表达式中包含所有内容，则可以这样做，尽管它可能不是人们所说的完全“干净”的代码：

[dcopy.pop() for dcopy in [list(d)] for _ in range(len(d))]

即，当人们确实想将赋值折叠到列表理解中时使用的常用技巧（添加一个 for 子句，其中“控制变量”是您要分配的名称，并且“循环”是在您要分配的值的单项序列上）。

函数式语言从不改变数据，因此它们也不复制（也不需要）。 Python 不是一种函数式语言，但是当然，您可以在 Python 中以“函数式方式”做很多事情，而且通常这是一种更好的方式。例如，对列表理解的更好替代（保证具有相同的结果并且不影响d，并且大大更快、更简洁，和清洁工）：（

d[::-1]

又名“火星笑脸”，根据我妻子安娜的说法；-）。切片（不是切片赋值，这是一个不同的操作）总是在核心Python（语言和标准库）中执行复制，尽管当然不一定在独立开发的第三方模块中，例如流行的numpy（它更喜欢将切片视为原始numpy.array上的“视图”）。

Answer 2

在此表达式中：

[d.pop() for _ in range(len(d))]

您希望隐式复制或限定什么变量？这里唯一在推导式中具有任何特殊状态的变量是 _，它不是您想要保护的变量。

我不明白如何提供列表推导式语义，以某种方式识别涉及的所有可变变量，并以某种方式隐式复制它们。或者知道 .pop() 改变了它的对象？

您提到了函数式语言，但它们通过使所有变量不可变来实现您想要的目的。 Python 根本就不是这样设计的。

Answer 3

为什么要创建一个（可能非常昂贵的）副本，而惯用的代码无论如何都不会产生副作用？为什么（罕见但现有的）需要副作用的用例（并且可以） ）被禁止？

Python 首先是一种命令式语言。可变状态不仅是允许的，而且是必不可少的 - 是的，列表理解旨在是纯粹的，但如果强制执行，它将与语言其余部分的语义异步。所以 d.pop() 会改变 d，但前提是它不在列表理解中并且星星是正确的？那是毫无意义的。你有自由（并且应该）不使用它，但没有人会一成不变地设置更多规则并使功能变得更复杂 - 惯用代码（这是任何人都应该关心的唯一代码;） ) 不需要这样的规则。无论如何它都会这样做，并且如果需要的话也会这样做。

Answer 4

d 不会被复制，因为您没有复制它，并且列表是可变的，并且 pop 通过契约操作列表。

如果您使用了元组，它就不会发生变化：

>>> x = (1, 2, 3, 4)
>>> type(x)
<type 'tuple'>
>>> x.pop()
AttributeError: 'tuple' object has no attribute 'pop'

Answer 5

为什么拥有列表是有利的
comps 的行为与 for 循环完全相同，

因为它最不令人惊讶。

而不是表现得更像函数
（具有本地范围）？

你在说什么？函数可以改变它们的参数：

>>> def mutate(d):
...     d.pop()
... 
>>> d = [1, 2, 3, 4, 5]
>>> mutate(d)
>>> d
[1, 2, 3, 4]

我完全没有看到任何不一致之处。

您似乎没有意识到 Python 不是一种函数式语言。它是一种命令式语言，恰好具有一些类似函数式的功能。 Python 允许对象是可变的。如果您不希望它们发生变异，那么就不要调用诸如 list.pop 之类的方法来改变它们。

Answer 6

您似乎误解了函数：

def fun(lst):
    for _ in range(len(lst)):
        lst.pop()

将具有与 This 完全相同的效果

(lst.pop() for _ in range(len(lst)))

，因为 lst 不是“the”列表，而是对它的引用。当您传递该引用时，它仍然指向同一个列表。如果您想要复制列表，只需使用lst[:]即可。如果您还想复制其内容，请使用 copy 模块中的 copy.deepcopy 。

Answer 7

当然有（例如队列处理）。但显然你所展示的不是一个。

Python 与任何值得使用的编程语言一样，完全按照您的指示执行，不多也不少。如果你想让它做别的事情，那就告诉它做别的事情。

Answer 8

Python 不是一种函数式语言，而且永远也不会。因此，当您使用列表理解时，您可以更改不相关数据结构的状态。这是无法合理阻止的，您所描述的措施只会对您强调的特定情况有所帮助。

一般来说，由使用列表理解的人来编写相当容易理解并且尽可能没有副作用的代码。我认为您发布的代码是糟糕的编程风格，并且是在 list.reverse 存在时创建反向列表的愚蠢方法。

不过，我想如果您在该示例中弹出的列表是一个队列，可以通过队列处理代码（即比 d.pop() 复杂得多）或通过另一个线程，那么代码是一种合理的做事方式。虽然我真的认为它应该是一个循环而不是列表理解。

Answer 9

您是说您希望方法根据执行上下文而表现不同吗？听起来对我来说真的很危险。

在 Python 对象上调用的方法总是会做同样的事情，这是一件好事 - 我担心使用一种语言，在某种语法结构中调用方法会导致其行为不同。

Answer 10

使用列表推导式时，总有一种方法可以不改变列表。但如果您想要的话，您也可以改变 list 。例如，在您的情况下：

c = [a for a in reversed(d)]
c = d[::-1]
c = [d[a] for a in xrange(len(d)-1, -1, -1)]

都会为您提供 list 的反向副本。 While

d.reverse()

会将 list 反转到位。

Answer 11

为什么 d 没有被复制，然后复制的词法范围版本没有发生变化（然后丢失）？

因为 python 是一种面向对象的编程语言，这样做将是一个非常糟糕的主意。 一切都是对象。

是什么让您认为可以创建任意对象的“词法范围副本”？

能够对对象调用 pop 并不意味着可以复制它。它可能会访问绕土星运行的空间探测器的文件句柄、网络套接字或指令队列。

---

为什么让列表组件的行为与 for 循环完全相同，而不是更像函数（具有本地作用域）？

1. 因为它创建了简洁、可读的代码。
2. 正如其他人所指出的，函数并不像您想象的那样工作。他们也不做这种“词法范围副本”的事情。我认为您对本地分配感到困惑。

---

我建议阅读这里的文章： http://www.cafepy.com/ Article/python_types_and_objects/python_types_and_objects.html

它们非常详细地介绍了 python 的工作原理。

Answer 12

如果我考虑一下你的“列表理解”，它本身就是“unpythonic”。
您通过 d.pop() 引用 d 并且实际上没有引用“列表理解”中的列表。
因此，实际上，您在使用模拟变量“_”的简单 for 循环中滥用了列表理解，而您并未将其用于此表达式中实际执行或收集的操作：“d.pop()”。
pop() 方法应用于 d。并且与 _ 和 range(len(d)) 无关 - 它只是使用 d 的长度创建另一个列表。
列表上的方法会改变列表本身。因此，通过应用此方法来改变 d 是“合乎逻辑的”。

正如 Alex Martelli 回答的那样，d[::-1] 以“pythonic”方式完成了该表达式应该做的事情。

Answer 13

我不确定你在问什么。也许您会问 d.pop() 是否应该返回一个副本而不是改变自身。 （这与列表推导式完全无关。）答案是否定的，当然不是：这会将其从 O(1) 操作转变为 O(n) 操作，这将是一个灾难性的设计缺陷。

至于列表推导式，没有什么可以阻止其中的表达式调用具有副作用的函数。如果你误用了列表推导式，这并不是列表推导式的错。强制阻止程序员做令人困惑的事情并不是语言设计的工作。

Answer 14

dan04 有正确的答案，为了进行比较，这里有一个小小的 Haskell...

[print s | s <- ["foo", "bar", "baz"]]

这里你在 Haskell 的列表理解中间有一个副作用（打印）。 Haskell 很懒，所以你必须使用 sequence_ 显式运行它：

main = sequence_ [print s | s <- ["foo", "bar", "baz"]]

但这实际上与 Python 相同，

_ = list(print(s) for s in ["foo", "baz", "baz"])

只是 Haskell 将 _ = list... 习惯用法包装在名为 的函数中sequence_。

列表推导式与防止副作用没有任何关系。只是没想到会在那里见到他们。而且你很难得到比 Haskell 更“实用”的东西，所以“Python 是一种命令式语言”的答案在这种情况下并不完全正确。