我来到这里是因为我想看看如何嵌套任意数量的列表。上面有很多解释和具体的例子，但是你可以概括出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]]]

上面已经演示了列表的非类型化性质

简单地说，这是因为在python中，一切都是通过引用工作的，所以当你以这种方式创建一个列表的列表时，你基本上会遇到这样的问题。

为了解决你的问题，你可以做其中之一: 1. 使用numpy.empty的numpy数组文档 2. 当您到达一个列表时，请添加该列表。 3.如果你愿意，你也可以用字典

[[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]]

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

当你写[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。

@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。

让我们按照以下方式重写代码:

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]]，与第一步的原因相同。