问题描述：

我想创建一系列长度各异的列表。每个列表将包含相同的元素e，重复n次数（其中n= 列表的长度）。

如何创建列表，而不[e for number in range(n)]对每个列表使用列表理解？

解决方案 1：

你也可以写：

[e] * n

您应该注意，如果 e 例如是一个空列表，您将得到一个包含 n 个对同一列表的引用的列表，而不是 n 个独立的空列表。

性能测试

乍一看，似乎repeat 是创建包含 n 个相同元素的列表的最快方法：

>>> timeit.timeit('itertools.repeat(0, 10)', 'import itertools', number = 1000000)
0.37095273281943264
>>> timeit.timeit('[0] * 10', 'import itertools', number = 1000000)
0.5577236771712819

但是等等——这不是一个公平的测试……

>>> itertools.repeat(0, 10)
repeat(0, 10)  # Not a list!!!

该函数itertools.repeat实际上并不创建列表，它只是创建一个对象，如果您愿意，可以使用该对象创建列表！让我们再试一次，但转换为列表：

>>> timeit.timeit('list(itertools.repeat(0, 10))', 'import itertools', number = 1000000)
1.7508119747063233

因此，如果您想要一个列表，请使用[e] * n。如果您想延迟生成元素，请使用repeat。

解决方案 2：

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

当重复项是列表时要小心。列表不会被克隆：所有元素都将引用同一个列表！

>>> x=[5]
>>> y=[x] * 4
>>> y
[[5], [5], [5], [5]]
>>> y[0][0] = 6
>>> y
[[6], [6], [6], [6]]

解决方案 3：

在 Python 中创建重复 n 次的单个项目列表

根据您的使用情况，您需要使用具有不同语义的不同技术。

将不可变项的列表相乘

对于不可变项，例如 None、bools、int、float、strings、tuples 或 freezesets，您可以这样做：

[e] * 4

例如：

>>> [None] * 4
[None, None, None, None]

请注意，这通常仅用于列表中的不可变项（字符串、元组、冻结集等），因为它们都指向内存中同一位置的同一项。

对于示例用例，当我必须构建一个包含所有字符串模式的表时，我会使用它，这样我就不必提供高度冗余的一对一映射。

schema = ['string'] * len(columns)

将列表相乘，以便重复显示具有可变状态的相同项目

将列表相乘会让我们一遍又一遍地得到相同的元素。这种情况并不常见：

[iter(iterable)] * 4

这有时用于将可迭代对象映射到列表列表中：

>>> iterable = range(12)
>>> a_list = [iter(iterable)] * 4
>>> [[next(l) for l in a_list] for i in range(3)] # uninteresting usage
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

我们可以看到a_list包含相同的范围迭代器四次：

>>> from pprint import pprint
>>> pprint(a_list)
[<range_iterator object at 0x7f9fe3b58420>,
 <range_iterator object at 0x7f9fe3b58420>,
 <range_iterator object at 0x7f9fe3b58420>,
 <range_iterator object at 0x7f9fe3b58420>]

可变项

我已经使用 Python 很长时间了，并且我很少看到使用可变对象执行上述操作的用例。

相反，为了重复可变的空列表、集合或字典，您应该执行以下操作：

list_of_lists = [[] for _ in iterator_of_needed_length]

在这种情况下，下划线只是一个一次性的变量名。

如果你只有数字，那就是：

list_of_lists = [[] for _ in range(4)]

一次性名称_并不是很特别，但如果您不打算使用该变量并使用任何其他名称，静态代码分析器可能会抱怨。

对可变项使用乘法的注意事项：

请谨慎对可变对象执行此操作，当您改变其中一个时，它们都会改变，因为它们都是同一个对象：

foo = [[]] * 4
foo[0].append('x')

foo 现在返回：

[['x'], ['x'], ['x'], ['x']]

但是对于不可变对象，你可以让它工作，因为你改变的是引用，而不是对象：

>>> l = [0] * 4
>>> l[0] += 1
>>> l
[1, 0, 0, 0]

>>> l = [frozenset()] * 4
>>> l[0] |= set('abc')
>>> l
[frozenset(['a', 'c', 'b']), frozenset([]), frozenset([]), frozenset([])]

但是，可变对象同样不适合这样做，因为就地操作会改变对象，而不是引用：

l = [set()] * 4
>>> l[0] |= set('abc')    
>>> l
[set(['a', 'c', 'b']), set(['a', 'c', 'b']), set(['a', 'c', 'b']), set(['a', 'c', 'b'])]

解决方案 4：

Itertools 有一个专门用于此的功能：

import itertools
it = itertools.repeat(e,n)

当然itertools会给你一个迭代器而不是列表。[e] * n给你一个列表，但是，根据你对这些序列的操作，itertools变体可以更加高效。

解决方案 5：

正如其他人指出的那样，对可变对象使用 * 运算符会重复引用，因此如果您更改一个引用，则会更改所有引用。如果您想创建可变对象的独立实例，则 xrange 语法是最符合 Python 风格的方式。如果您对从未使用过的命名变量感到困扰，则可以使用匿名下划线变量。

[e for _ in xrange(n)]

解决方案 6：

[e] * n

应该有效

解决方案 7：

如果您正在寻找一个简单的重复，例如：

[1, 2, 3, 1, 2, 3, 1, 2, 3]

只需使用：

[1, 2, 3] * 3

但如果你正在寻找：

[1, 1, 1, 2, 2, 2, 3, 3, 3]

这个更好，但需要更多时间：

numpy.concatenate([([i]*3) for i in [1,2,3]], axis=0)

解决方案 8：

抱歉我回答得太晚了您可以numpy.repeat轻松使用。只需写下您想要产生的值和重复次数即可。

import numpy as np
x = [1,2,3]
y = np.linspace(0,1000,10000)
for i in x:
    new_x = np.repeat(i,len(y))
    print(new_x)

解决方案 9：

如果你正在寻找

[1, 1, 1, 2, 2, 2, 3, 3, 3]

如果没有 numpy，你可以使用内置的 itertools 模块

from itertools import chain
list(chain.from_iterable(zip(*[[1,2,3]]*3)))

使用简单的列表理解（甚至不需要 itertools）

[e for x in zip(*[[1,2,3]]*3) for e in x]

解决方案 10：

import numpy as np
a = np.full(fill_value=1, shape=3)
print(a)
b = np.repeat(a=[1,2,3],repeats=3)
print(b)
c = np.repeat(a=[[1,2,3]],repeats=3,axis=0).flatten()
print(c)