[[1] * 4] * 3

甚至:

[[1, 1, 1, 1]] * 3

创建一个3次引用内部[1,1,1,1]的列表——而不是内部列表的3个副本，因此任何时候修改列表(在任何位置)，您都会看到3次更改。

和下面这个例子一样:

>>> inner = [1,1,1,1]
>>> outer = [inner]*3
>>> outer
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
>>> inner[0] = 5
>>> outer
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]

在那里可能不那么令人惊讶。

我正在补充我的答案，以图解方式解释同样的问题。

你创建2D的方式，创建一个浅列表

arr = [[0]*cols]*row

相反，如果您希望更新列表中的元素，则应该使用

rows, cols = (5, 5) 
arr = [[0 for i in range(cols)] for j in range(rows)] 

解释:

可以使用以下命令创建列表:

arr = [0]*N 

or

arr = [0 for i in range(N)] 

在第一种情况下，数组的所有下标都指向同一个整数对象

当你给一个特定的索引赋值时，就会创建一个新的int对象，例如arr[4] = 5

现在让我们看看当我们创建一个list of list时会发生什么，在这种情况下，top list的所有元素都指向同一个列表

如果你更新任何索引的值，就会创建一个新的int对象。但是由于所有顶级列表索引都指向同一个列表，所以所有行看起来都是一样的。您会觉得更新一个元素就是更新该列中的所有元素。

感谢Pranav Devarakonda提供的简单解释

size = 3
matrix_surprise = [[0] * size] * size
matrix = [[0]*size for _ in range(size)]

使用Python导师进行实时可视化:

当你写[x]*3时，你会得到[x, x, x]这个列表。也就是说，一个有3个对同一个x的引用的列表。当你修改这个x时，它通过所有三个对它的引用都是可见的:

x = [1] * 4
xs = [x] * 3
print(f"id(x): {id(x)}")
# id(x): 140560897920048
print(
    f"id(xs[0]): {id(xs[0])}\n"
    f"id(xs[1]): {id(xs[1])}\n"
    f"id(xs[2]): {id(xs[2])}"
)
# id(xs[0]): 140560897920048
# id(xs[1]): 140560897920048
# id(xs[2]): 140560897920048

x[0] = 42
print(f"x: {x}")
# x: [42, 1, 1, 1]
print(f"xs: {xs}")
# xs: [[42, 1, 1, 1], [42, 1, 1, 1], [42, 1, 1, 1]]

为了解决这个问题，您需要确保在每个位置都创建了一个新列表。一种方法是

[[1]*4 for _ in range(3)]

它将每次重新计算[1]*4，而不是计算一次并对1个列表进行3次引用。

You might wonder why * can't make independent objects the way the list comprehension does. That's because the multiplication operator * operates on objects, without seeing expressions. When you use * to multiply [[1] * 4] by 3, * only sees the 1-element list [[1] * 4] evaluates to, not the [[1] * 4 expression text. * has no idea how to make copies of that element, no idea how to reevaluate [[1] * 4], and no idea you even want copies, and in general, there might not even be a way to copy the element.

*的唯一选择是对现有子列表进行新的引用，而不是尝试创建新的子列表。其他任何东西都是不一致的，或者需要对基本语言设计决策进行重大的重新设计。

相比之下，列表推导式在每次迭代时重新计算元素表达式。[[1] * 4 for n in range(3)]每次重新计算[1]* 4，原因相同[x**2 for x in range(3)]每次重新计算x**2。每次对[1]* 4求值都会生成一个新列表，因此列表推导式执行您想要的操作。

顺便说一句，[1]* 4也不复制[1]的元素，但这没关系，因为整数是不可变的。你不能做类似于1的东西。Value = 2，把1变成2。

My_list =[[1]*4] * 3在内存中创建一个列表对象[1,1,1,1]，并将其引用复制3次。这相当于obj = [1,1,1,1];My_list = [obj]*3。对obj的任何修改都将反映在列表中引用obj的三个位置。 正确的说法应该是:

my_list = [[1]*4 for _ in range(3)]

or

my_list = [[1 for __ in range(4)] for _ in range(3)]

这里需要注意的重要一点是，*操作符主要用于创建文字列表。虽然1是不可变的，但obj =[1]*4仍然会创建一个重复4次的1的列表，形成[1,1,1,1]。但是，如果对不可变对象进行了引用，则该对象将被一个新的对象覆盖。

这意味着如果我们执行obj[1] = 42，那么obj将变成[1,42,1,1]，而不是一些人可能认为的[42,42,42,42]。这也可以验证:

>>> my_list = [1]*4
>>> my_list
[1, 1, 1, 1]

>>> id(my_list[0])
4522139440
>>> id(my_list[1])  # Same as my_list[0]
4522139440

>>> my_list[1] = 42  # Since my_list[1] is immutable, this operation overwrites my_list[1] with a new object changing its id.
>>> my_list
[1, 42, 1, 1]

>>> id(my_list[0])
4522139440
>>> id(my_list[1])  # id changed
4522140752
>>> id(my_list[2])  # id still same as my_list[0], still referring to value `1`.
4522139440

除了正确解释问题的可接受答案之外，使用以下代码创建具有重复元素的列表:

[[1]*4 for _ in range(3)]

同样，你可以使用itertools.repeat()创建一个重复元素的迭代器对象:

>>> a = list(repeat(1,4))
[1, 1, 1, 1]
>>> a[0] = 5
>>> a
[5, 1, 1, 1]

注:如果你使用NumPy，你只想创建一个数组的1或0，你可以使用np。1和np。0和/或其他数字使用np.repeat:

>>> import numpy as np
>>> np.ones(4)
array([1., 1., 1., 1.])
>>> np.ones((4, 2))
array([[1., 1.],
       [1., 1.],
       [1., 1.],
       [1., 1.]])
>>> np.zeros((4, 2))
array([[0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.]])
>>> np.repeat([7], 10)
array([7, 7, 7, 7, 7, 7, 7, 7, 7, 7])