为什么创建列表列表会产生意外行为？

Question

编辑：这个问题是关于为什么行为是什么，而不是如何绕过它，这就是所谓的重复是关于。

---

我在不同情况下使用了以下符号来创建一定大小的列表。例如：

>>> [None] * 5
[None, None, None, None, None]
>>>

这似乎按预期工作，并且比：

>>> [None for _ in range(5)]
[None, None, None, None, None]
>>>

然后我尝试使用相同的方法创建一个列表列表：

>>> [[]] * 5
[[], [], [], [], []]
>>>

很公平。它似乎按预期工作。

但是，在通过调试器时，我注意到 所有 子列表存储桶具有相同的值，即使我只添加了一个 单个 项。例如：

>>> t = [[]] * 5
>>> t
[[], [], [], [], []]
>>> t[1].append(4)
>>> t
[[4], [4], [4], [4], [4]]
>>> t[0] is t[1]
True
>>>

我没想到所有顶级数组元素都是对单个子列表的引用；我预计有 5 个独立子列表。

为此，我不得不编写如下代码：

>>> t = [[] for _ in range(5)]
>>> t
[[], [], [], [], []]
>>> t[2].append(4)
>>> t
[[], [], [4], [], []]
>>> t[0] is t[1]
False
>>>

我显然遗漏了一些东西，可能是一个历史事实，或者只是一种不同的方式来看待这里的一致性。

谁能解释一下为什么两个不同的代码 sn-ps 可以合理地期望彼此等效，实际上最终会隐式产生不同且不明显 (IMO) 的结果，尤其是考虑到 Python 的 zen总是明确和明显？

请注意，我已经知道this question，这与我所要求的不同。

我只是在寻找详细的解释/理由。如果此行为存在历史、技术和/或理论原因，请务必提供一两个参考资料。

Answer 1

当您执行以下操作时：

[[]]*n

您首先创建一个列表，然后使用* 运算符和int n。这将获取列表中的任何对象，并创建它的 n 次重复。

但由于在 Python 中，显式优于隐式，因此您不会隐式复制这些对象。确实，这与 Python 的语义是一致的。

尝试列举一个 Python 隐式复制的案例。

另外，与榜单上的添加一致：

l = [1, [], 'a']

l2 = l + l + l

l[1].append('foo')

print(l2)

还有输出：

[1, ['foo'], 'a', 1, ['foo'], 'a', 1, ['foo'], 'a']

现在，正如 cmets 中所指出的，来自 C++，上面的内容令人惊讶是有道理的，但如果一个人习惯了 Python，那么上面就是人们所期望的。

另一方面：

[[] for _ in range(5)]

是一个列表推导。相当于：

lst = []
for _ in range(5):
    lst.append([])

在这里，很明显，每次您进入循环时，您都会创建一个新列表。这就是字面语法的工作原理。

顺便说一句，我几乎从不在列表中使用* 运算符，除了我喜欢的一个特定习语：

>>> x = list(range(1, 22))
>>> it_by_three = [iter(x)]*3
>>> for a,b,c in zip(*it_by_three):
...    print(a, b, c)
...
1 2 3
4 5 6
7 8 9
10 11 12
13 14 15
16 17 18
19 20 21

Answer 2

对于cpython，相关部分源码在listobject.c中的函数list_repeat中。下面重复了一个启发性的 sn-p，并添加了我添加的 cmets：

np = (PyListObject *) PyList_New(size);  // make a new PyListObject

/* some code omitted */

items = np->ob_item;          // grabs the list of pointers of the *new* object
if (Py_SIZE(a) == 1) {        // this is the case for a 1-element list being multiplied
    elem = a->ob_item[0];     // grabs the pointer of the element of the *original* object
    for (i = 0; i < n; i++) {
        items[i] = elem;      // assigns the original pointer to the new list
        Py_INCREF(elem);
    }
    return (PyObject *) np;
}

由于PyListObject 主要是一个包含指向列表元素的指针列表的Vector，因此将这些点作为元素分配给新的PyListObject 很简单。

相反，想象一下如果需要复制位于每个指针处的对象的代码。它会更复杂，并且会对性能造成显着影响。但是，我不会推测这个设计决策的动机。