我创建了一个列表的列表:
>>> xs = [[1] * 4] * 3
>>> print(xs)
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
然后，我改变了最里面的一个值:
>>> xs[0][0] = 5
>>> print(xs)
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]
为什么每个子列表的第一个元素都变成了5?
参见:
我如何克隆一个列表，使它不会在分配后意外改变?寻找解决问题的方法
Python:对于字典列表的类似问题，字典列表只存储每次迭代中最后追加的值
如何初始化一个字典，其值是不同的空列表?对于列表字典的类似问题
当前回答
我来到这里是因为我想看看如何嵌套任意数量的列表。上面有很多解释和具体的例子，但是你可以概括出N维的列表的列表的列表的列表…用以下递归函数:
import copy
def list_ndim(dim, el=None, init=None):
if init is None:
init = el
if len(dim)> 1:
return list_ndim(dim[0:-1], None, [copy.copy(init) for x in range(dim[-1])])
return [copy.deepcopy(init) for x in range(dim[0])]
第一次调用函数是这样的:
dim = (3,5,2)
el = 1.0
l = list_ndim(dim, el)
其中(3,5,2)是结构尺寸的元组(类似于numpy shape参数)，1.0是你想要初始化结构的元素(也适用于None)。请注意，init参数仅由递归调用提供，用于向前携带嵌套的子列表
以上输出:
[[[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0]],
[[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0]],
[[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0]]]
设置具体元素:
l[1][3][1] = 56
l[2][2][0] = 36.0+0.0j
l[0][1][0] = 'abc'
输出结果:
[[[1.0, 1.0], ['abc', 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0]],
[[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 56.0], [1.0, 1.0]],
[[1.0, 1.0], [1.0, 1.0], [(36+0j), 1.0], [1.0, 1.0], [1.0, 1.0]]]
上面已经演示了列表的非类型化性质
其他回答
让我们按照以下方式重写代码:
x = 1
y = [x]
z = y * 4
my_list = [z] * 3
有了这些，运行下面的代码使一切更清楚。代码所做的基本上是打印所获得的对象的id，这
返回一个对象的“标识符”
并将帮助我们识别它们并分析发生了什么:
print("my_list:")
for i, sub_list in enumerate(my_list):
print("\t[{}]: {}".format(i, id(sub_list)))
for j, elem in enumerate(sub_list):
print("\t\t[{}]: {}".format(j, id(elem)))
您将得到以下输出:
x: 1
y: [1]
z: [1, 1, 1, 1]
my_list:
[0]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[1]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
[2]: 4300763792
[0]: 4298171528
[1]: 4298171528
[2]: 4298171528
[3]: 4298171528
现在让我们一步一步来。你有x，它是1，和一个包含x的元素列表y。你的第一步是y * 4，它会得到一个新的列表z，基本上是[x, x, x, x]，也就是说，它创建了一个新的列表，它将有4个元素，它们是对初始x对象的引用。下一步非常相似。基本上是z * 3，即[[x, x, x]] * 3，并返回[[x, x, x]， [x, x, x]， [x, x, x]]，与第一步的原因相同。
size = 3
matrix_surprise = [[0] * size] * size
matrix = [[0]*size for _ in range(size)]
使用Python导师进行实时可视化:
每个人都在解释发生了什么。我将提出一种解决方法:
my_list = [[1 for i in range(4)] for j in range(3)]
my_list[0][0] = 5
print(my_list)
然后你得到:
[[5, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
简单地说，这是因为在python中，一切都是通过引用工作的，所以当你以这种方式创建一个列表的列表时，你基本上会遇到这样的问题。
为了解决你的问题，你可以做其中之一: 1. 使用numpy.empty的numpy数组文档 2. 当您到达一个列表时，请添加该列表。 3.如果你愿意，你也可以用字典
@spelchekr from Python list乘法:[[…]*3制作了3个列表，这些列表在修改时相互镜像，我有同样的问题 “为什么只有外层的*3会产生更多的参考，而内部的则不会?”为什么不都是1s?”
li = [0] * 3
print([id(v) for v in li]) # [140724141863728, 140724141863728, 140724141863728]
li[0] = 1
print([id(v) for v in li]) # [140724141863760, 140724141863728, 140724141863728]
print(id(0)) # 140724141863728
print(id(1)) # 140724141863760
print(li) # [1, 0, 0]
ma = [[0]*3] * 3 # mainly discuss inner & outer *3 here
print([id(li) for li in ma]) # [1987013355080, 1987013355080, 1987013355080]
ma[0][0] = 1
print([id(li) for li in ma]) # [1987013355080, 1987013355080, 1987013355080]
print(ma) # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
下面是我在尝试上面的代码后的解释:
内部的*3也创建引用，但它的引用是不可变的，就像[&0，&0，&0]，那么当你改变li[0]时，你不能改变const int 0的任何底层引用，所以你可以只改变引用地址为新的&1; 而ma = [&li， &li， &li]且li是可变的，因此当你调用ma[0][0] = 1时，ma[0][0]等于&li[0]，因此所有的&li实例将其第一个地址更改为&1。
