在 Python 中创建一个具有一定大小的空列表答案

【问题标题】：Create an empty list in Python with certain size在 Python 中创建一个具有一定大小的空列表
【发布时间】：2012-05-29 12:46:58
【问题描述】：

我想创建一个可以容纳 10 个元素的空列表（或任何最好的方法）。

之后我想在该列表中分配值，例如这应该显示 0 到 9：

s1 = list();
for i in range(0,9):
   s1[i] = i

print s1

但是当我运行这段代码时，它会产生一个错误，或者在另一种情况下它只显示[]（空）。

谁能解释一下原因？

【问题讨论】：

Initializing a list to a known number of elements in Python的可能重复
根据定义，“空列表”([]) 有零个元素。您显然想要的是一个虚假值列表，例如 None、0 或 ''。
要生成从0 到9 的列表，您实际上应该使用for i in range(0, 10)，这意味着for (int i = 0, i < 10, i++)。

标签： python list

【解决方案1】：

您不能分配给像lst[i] = something 这样的列表，除非该列表已经使用至少i+1 元素进行了初始化。您需要使用 append 将元素添加到列表的末尾。 lst.append(something).

（如果您使用字典，则可以使用赋值符号）。

创建一个空列表：

>>> l = [None] * 10
>>> l
[None, None, None, None, None, None, None, None, None, None]

为上述列表的现有元素赋值：

>>> l[1] = 5
>>> l
[None, 5, None, None, None, None, None, None, None, None]

请记住，l[15] = 5 之类的内容仍然会失败，因为我们的列表只有 10 个元素。

range(x) 从 [0, 1, 2, ... x-1] 创建一个列表

# 2.X only. Use list(range(10)) in 3.X.
>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用函数创建列表：

>>> def display():
...     s1 = []
...     for i in range(9): # This is just to tell you how to create a list.
...         s1.append(i)
...     return s1
... 
>>> print display()
[0, 1, 2, 3, 4, 5, 6, 7, 8]

列表理解（使用正方形，因为对于范围，您不需要执行所有这些操作，只需返回 range(0,9)）：

>>> def display():
...     return [x**2 for x in range(9)]
... 
>>> print display()
[0, 1, 4, 9, 16, 25, 36, 49, 64]

【讨论】：

“您不能分配给像 lst[i] = something 这样的列表”是什么意思——当然可以！你不能做的是分配给超出当前列表长度的不存在的元素
"除非列表已经用至少 i+1 个元素初始化"....
你可以这样做：a = [0 for _ in range(10)]
如果您尝试创建固定大小的矩阵/二维列表，这将不起作用。请参阅 James L. 和 user2233706 的答案。
为什么python没有专业的函数来初始化一个空的n维列表？

【解决方案2】：

试试这个：

lst = [None] * 10

上面将创建一个大小为 10 的列表，其中每个位置都初始化为 None。之后，您可以向其中添加元素：

lst = [None] * 10
for i in range(10):
    lst[i] = i

诚然，这不是 Python 的做事方式。最好这样做：

lst = []
for i in range(10):
    lst.append(i)

或者更简单，在 Python 2.x 中，您可以这样做来初始化一个值从 0 到 9 的列表：

lst = range(10)

在 Python 3.x 中：

lst = list(range(10))

【讨论】：

另一个很棒的事情是你可以用默认值初始化一个列表。 lst = [''] * 10 或 lst = [0] * 10
理解示例的变体。如果数组中的所有元素在初始化时都需要为空，请使用：arr = [None for _ in range(10)]。
这种格式是lst = list(range(10)) 看起来不错。就像Java中的相同长度int [] arr = new int[10]
为什么第一个例子不是“pythonic”做事的方式？
@twistedpixel 因为你不应该使用索引来访问 for 循环中的元素除非你真的需要它。大多数情况下首选简单的for element in theList。

【解决方案3】：

varunl 当前接受的答案

 >>> l = [None] * 10
 >>> l
 [None, None, None, None, None, None, None, None, None, None]

适用于数字等非引用类型。不幸的是，如果您想创建列表列表，您将遇到引用错误。 Python 2.7.6 中的示例：

>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
>>>

如您所见，每个元素都指向同一个列表对象。为了解决这个问题，您可以创建一个方法，将每个位置初始化为不同的对象引用。

def init_list_of_objects(size):
    list_of_objects = list()
    for i in range(0,size):
        list_of_objects.append( list() ) #different object reference each time
    return list_of_objects


>>> a = init_list_of_objects(10)
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [], [], [], [], [], [], [], [], []]
>>>

可能有一种默认的内置 python 方式来执行此操作（而不是编写函数），但我不确定它是什么。很高兴得到纠正！

编辑：这是[ [] for _ in range(10)]

例子：

>>> [ [random.random() for _ in range(2) ] for _ in range(5)]
>>> [[0.7528051908943816, 0.4325669600055032], [0.510983236521753, 0.7789949902294716], [0.09475179523690558, 0.30216475640534635], [0.3996890132468158, 0.6374322093017013], [0.3374204010027543, 0.4514925173253973]]

【讨论】：

我听说经常使用append 不如列表推导式。您可以通过[ [] for _ in range(10)] 创建您的列表。
投了赞成票，因为我生气了，因为我有多次重复相同数据的多维数组，并且在最终找到这个答案之前无法弄清楚发生了什么。^^我不明白为什么这里太低了。

【解决方案4】：

您可以.append(element) 加入列表，例如：s1.append(i)。您当前尝试做的是访问一个不存在的元素 (s1[i])。

【讨论】：

【解决方案5】：

有两种“快速”方法：

x = length_of_your_list
a = [None]*x
# or
a = [None for _ in xrange(x)]

看来[None]*x 更快：

>>> from timeit import timeit
>>> timeit("[None]*100",number=10000)
0.023542165756225586
>>> timeit("[None for _ in xrange(100)]",number=10000)
0.07616496086120605

但如果您对某个范围没问题（例如[0,1,2,3,...,x-1]），那么range(x) 可能是最快的：

>>> timeit("range(100)",number=10000)
0.012513160705566406

【讨论】：

请注意，在 Python3 中，您必须改用 list(range(n))，因为 range() 不返回列表，而是一个迭代器，这并不比 [None] * n 快。

【解决方案6】：

我很惊讶没有人建议使用这种简单的方法来创建空列表列表。这是一个旧线程，但只是为了完整性而添加它。这将创建一个包含 10 个空列表的列表

x = [[] for i in range(10)]

【讨论】：

执行上述操作与执行x = [[]] * 10 之间最重要的区别在于，在后者中，列表中的每个元素都指向同一个列表对象。因此，除非您只是想要同一对象的 10 个副本，否则请使用基于 range 的变体，因为它会创建 10 个 new 对象。我发现这种区别非常重要。

【解决方案7】：

接受的答案有一些问题。例如：

>>> a = [{}] * 3
>>> a
[{}, {}, {}]
>>> a[0]['hello'] = 5
>>> a
[{'hello': 5}, {'hello': 5}, {'hello': 5}]
>>>

所以每个字典都指向同一个对象。如果您使用数组或对象进行初始化，同样适用。

你可以这样做：

>>> b = [{} for i in range(0, 3)]
>>> b
[{}, {}, {}]
>>> b[0]['hello'] = 6
>>> b
[{'hello': 6}, {}, {}]
>>>

【讨论】：

上述方法适用于列表中每个“dict”的“单个”键值输入。我们不能将另一对添加到“b[0]”。因此，使用“.append”或“.extend”方法总是比简单地分配值更好。它适用于每个组合，例如 tuple(list)、list(list) 等。

【解决方案8】：

（这是根据问题的原始版本编写的。）

我想创建一个可以容纳 10 个元素的空列表（或任何最好的方法）。

所有列表都可以包含任意数量的元素，仅受可用内存的限制。列表的唯一“大小”是其中当前元素的数量。

但是当我运行它时，结果是[]

print display s1 语法无效；根据您对所见内容的描述，我假设您的意思是display(s1)，然后是print s1。要运行它，您必须事先定义一个全局 s1 以传递给函数。

调用display 不会修改您传入的列表，如所写。您的代码显示“s1 是传入函数的任何东西的名称；好的，现在我们要做的第一件事就是完全忘记那个东西，让s1 开始引用新创建的@ 987654328@。现在我们将修改 list"。这对您传入的值没有影响。

这里没有理由传入一个值。（也没有真正的理由来创建一个函数，但这不是重点。）你想“创建”一些东西，所以这就是你的函数的输出。创建您描述的内容不需要任何信息，因此请勿传入任何信息。要获取信息，请return it。

这会给你类似的东西：

def display():
    s1 = list();
    for i in range(0, 9):
        s1[i] = i
    return s1

您将注意到的下一个问题是您的列表实际上只有 9 个元素，因为range 函数跳过了终点。（作为旁注，[] 和 list() 一样有效，分号是不必要的，s1 是变量的一个糟糕的名称，如果你从 @ 开始，range 只需要一个参数987654337@.) 所以你最终得到了

def create_list():
    result = list()
    for i in range(10):
        result[i] = i
    return result

但是，这仍然是错误的； range 不是像 for 和 def 那样是语言的一部分的神奇关键字，而是一个函数。猜猜那个函数返回什么？没错——这些整数的列表。所以整个函数折叠成

def create_list():
    return range(10)

现在你明白为什么我们根本不需要自己编写函数了； range 已经是我们正在寻找的功能。不过，再一次，没有必要或没有理由“预先确定”列表的大小。

【讨论】：

【解决方案9】：

一种使用嵌套列表推导式创建大小为n 的二维矩阵的简单方法：

m = [[None for _ in range(n)] for _ in range(n)]

【讨论】：

每个嵌套列表实际上都是对同一个列表的引用。快速修复如下：[[None for _ in range(2)].copy() for _ in range(2)]

【解决方案10】：

我有点惊讶的是，创建初始化列表的最简单方法不在这些答案中。只需在list 函数中使用生成器即可：

list(range(9))

【讨论】：

有点好奇为什么还有人在这个上面...我是 python 菜鸟，我这个看起来像是要走的路，但没有人说什么。也许范围函数可能很昂贵或其他什么？
这个问题是这个答案不会根据问题创建一个空列表，你最终会得到 [0, 1, 2, 3, 4, 5, 6, 7 ,8] 这是range(9) 函数的作用。假设实例化一个无列表是有用的，而不是立即用数字填充它
为什么将range(9) 包裹在list() 中？ range(9) 不是已经返回列表了吗？
@Zyl range 不是列表，也不是生成器。它是Sequence 的内置不可变子类。
@AFP_555 我认为真正的问题是为什么它没有被更多人否决，因为它并没有真正回答问题并且可能会产生意想不到的不良后果。

【解决方案11】：

这是我在 python 中的 2D 列表代码，它会读取 no。输入的行数：

empty = []
row = int(input())

for i in range(row):
    temp = list(map(int, input().split()))
    empty.append(temp)

for i in empty:
    for j in i:
        print(j, end=' ')
    print('')

【讨论】：

【解决方案12】：

在技术上不是列表，但在功能上类似于列表，并且是固定长度

from collections import deque
my_deque_size_10 = deque(maxlen=10)

如果它已满，即有 10 个项目，然后添加另一个项目会导致项目 @index 0 被丢弃。 FIFO ..但您也可以向任一方向追加。用在说

统计数据的滚动平均值
通过管道传递列表，也就是在列表上滑动窗口，直到与另一个双端队列对象匹配。

如果你需要一个列表，那么当满时只需使用 list(deque object)

【讨论】：

【解决方案13】：

这里是如何将零添加到二维数组。获取数组的形状，然后使用 np.zeros 构建一个新数组，然后用新数组填充旧数组

def add_zeros(arr):
    """
    :param arr: 2d array
    :return: 2d array with zeros added to the right and bottom
    """
    # get the shape of the array
    shape = arr.shape
    # get the number of rows and columns
    rows = shape[0]
    cols = shape[1]
    # create a new array with the same number of rows and columns
    new_arr = np.zeros((rows, cols))
    # copy the values from the original array to the new array
    for i in range(rows):
        for j in range(cols):
            new_arr[i, j] = arr[i, j]
    # add zeros to the bottom and right of the array
    new_arr = np.pad(new_arr, pad_width=((0, 1), (0, 1)), mode='constant', constant_values=0)
    return new_arr

【讨论】：

【解决方案14】：

另一种选择是将 numpy 用于固定大小的数组（指针）：

> pip install numpy

import numpy as np


a = np.empty(10, dtype=np.object)
a[1] = 2
a[5] = "john"
a[3] = []

如果你只想要数字，你可以用 numpy：

a = np.arange(10)

【讨论】：

【解决方案15】：

我在搜索类似问题时遇到了这个 SO 问题。我必须构建一个二维数组，然后用字典中的元素替换每个列表（在二维数组中）的一些元素。然后我遇到了this SO 问题，这对我有帮助，也许这会帮助其他初学者绕过。关键技巧是将二维数组初始化为 numpy 数组，然后使用 array[i,j] 而不是 array[i][j]。

作为参考，这是我必须使用的一段代码：

nd_array = []
for i in range(30):
    nd_array.append(np.zeros(shape = (32,1)))
new_array = []
for i in range(len(lines)):
    new_array.append(nd_array)
new_array = np.asarray(new_array)
for i in range(len(lines)):
    splits = lines[i].split(' ')
    for j in range(len(splits)):
        #print(new_array[i][j])
        new_array[i,j] = final_embeddings[dictionary[str(splits[j])]-1].reshape(32,1)

现在我知道我们可以使用列表推导，但为了简单起见，我使用了嵌套的 for 循环。希望这可以帮助其他看到这篇文章的人。

【讨论】：

【解决方案16】：

s1 = []
for i in range(11):
   s1.append(i)

print s1

要创建一个列表，只需使用这些括号：“[]”

要将某些内容添加到列表中，请使用 list.append()

【讨论】：

【解决方案17】：

使其作为函数更可重用。

def createEmptyList(length,fill=None):
    '''
    return a (empty) list of a given length
    Example:
        print createEmptyList(3,-1)
        >> [-1, -1, -1]
        print createEmptyList(4)
        >> [None, None, None, None]
    '''
    return [fill] * length

【讨论】：

【解决方案18】：

此代码生成一个包含 10 个随机数的数组。

import random
numrand=[]
for i in range(0,10):
   a = random.randint(1,50)
   numrand.append(a)
   print(a,i)
print(numrand)

【讨论】：

欢迎来到 SO。您的回答并没有真正解决这个问题。看看stackoverflow.com/help/how-to-answer