您可以将（元素）追加到列表中，例如：

s1.append(i)

您当前试图做的是访问不存在的元素（s1[i]）。

请尝试以下操作：

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)

或者更简单的是，在Python2.x中，您可以这样做，用0到9的值初始化列表：

lst = range(10)

在Python 3.x中：

lst = list(range(10))

除非列表已经用至少i+1个元素初始化，否则不能向xs[i]=value这样的列表赋值。相反，使用xs.append（value）将元素添加到列表末尾。（虽然如果使用字典而不是列表，则可以使用赋值符号。）

创建空列表：

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

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

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

请记住，像xs[15]=5这样的东西仍然会失败，因为我们的列表只有10个元素。

range（x）从[0，1，2，…x-1]创建列表

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

使用函数创建列表：

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

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

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

如何创建可容纳10个元素的空列表？

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

但是，这会导致IndexError:list赋值索引超出范围。为什么？

第一次通过循环时，i等于0。因此，我们尝试xs[0]=0。这不起作用，因为列表中当前有0个元素，因此0不是有效的索引。

我们不能使用索引来写入不存在的列表元素——我们只能覆盖现有的元素。相反，我们应该使用.append方法：

xs = list();
for i in range(0, 9):
   xs.append(i)

您将注意到的下一个问题是，列表实际上只有9个元素，因为范围函数跳过了终点。（正如旁注：[]与list（）一样有效，分号是不必要的，如果从0开始，范围只需要一个参数。）解决这些问题可以：

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

然而，这仍然缺少标记-range并不是某种神奇的关键字，它是语言的一部分，例如def。

在2.x中，range是一个函数，它直接返回我们已经想要的列表：

xs = range(10) # 2.x specific!
# In 3.x, we don't get a list; we can do a lot of things with the
# result, but we can't e.g. append or replace elements.

在3.x中，range是一个设计巧妙的类，range（10）创建了一个实例。为了获得所需的列表，我们可以简单地将其输入到列表构造函数：

xs = list(range(10)) # correct in 3.x, redundant in 2.x

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方式（而不是编写函数），但我不确定它是什么。很高兴得到更正！

编辑：范围（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]]

有两种“快速”方法：

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]）很满意，那么范围（x）可能是最快的：

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

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

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

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

print s1

要创建列表，只需使用以下括号：“[]”

要向列表中添加内容，请使用list.append（）

这是我的python 2D列表代码，它将从输入中读取行数：

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('')

我在寻找类似问题时遇到了这个SO问题。我必须构建一个2D数组，然后用dict中的元素替换每个列表中的一些元素（在2D数组中）。然后我遇到了这个SO问题，这对我很有帮助，也许这会帮助其他初学者。关键技巧是将2D数组初始化为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循环。希望这能帮助其他看到这篇文章的人。

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

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

使其作为一个函数更加可重用。

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

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

list(range(9))

使用嵌套列表综合创建大小为n的2D矩阵的一种简单方法：

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

公认的答案有一些陷阱。例如：

>>> 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}, {}, {}]
>>> 

从技术上讲，它不是一个列表，但在功能上与列表相似，并且长度固定

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

如果它已满，即获得10个项目，则添加另一个项目会导致项目@index 0被丢弃。第五。。但也可以在任意方向上追加。用于say

统计数据的滚动平均值在列表上滑动窗口，直到与另一个deque对象匹配。

如果您需要一个列表，那么当列表满时，只需使用列表（deque对象）

另一个选项是对固定大小的数组（指针）使用numpy：

>pip安装数

import numpy as np


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

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

a = np.arange(10)

列表始终是“可迭代的”，您可以始终向其中添加新元素：

insert:list.insert（indexPosition，value）append:list.append（值）扩展：列表扩展（值）

在您的例子中，您实例化了一个长度为0的空列表。因此，当您尝试使用列表索引（i）向列表中添加任何值时，它指的是不存在的位置。因此，您得到了错误“IndexError:list赋值索引超出范围”。

您可以改为尝试：

s1 = list();
for i in range(0,9):
   s1.append(i)

print (s1)

要创建一个大小为10的列表（比方说），可以先创建一个空数组，比如np.empty（10），然后使用arrayName.tolist（）将其转换为列表。或者，也可以将它们链接起来。

            **`np.empty(10).tolist()`**