variable = []

现在variable指向一个空列表^＊。

当然，这是赋值，不是声明。因为Python是动态类型的，所以在Python中没有办法说“这个变量永远不应该指列表以外的任何东西”。

默认的内置Python类型被称为列表，而不是数组。它是一个任意长度的有序容器，可以容纳异构的对象集合(它们的类型无关紧要，可以自由混合)。这不应该与# EYZ0模块混淆，后者提供了更接近c# EYZ0类型的类型;内容必须是同质的(都是同一类型)，但是长度仍然是动态的。

是这样的:

my_array = [1, 'rebecca', 'allard', 15]

你不需要在Python中声明任何东西。你只需使用它。我建议你从http://diveintopython.net开始。

我通常只做a = [1,2,3]，实际上是list，但对于arrays，看看这个正式的定义

你实际上不需要声明东西，但这是在Python中创建数组的方法:

from array import array
intarray = array('i')

有关更多信息，请参阅数组模块:http://docs.python.org/library/array.html

现在可能你不想要数组，而是一个列表，但其他人已经回答了这个问题。：）

继Lennart之后，还有numpy，它实现了同构多维数组。

我认为你(意思是)想要一个列表与前30个单元格已经填充。 所以< / p >

   f = []


for i in range(30):
f.append(0)

计算时，使用numpy数组，如下所示:

import numpy as np


a = np.ones((3,2))        # a 2D array with 3 rows, 2 columns, filled with ones
b = np.array([1,2,3])     # a 1D array initialised using a list [1,2,3]
c = np.linspace(2,3,100)  # an array with 100 points beteen (and including) 2 and 3


print(a*1.5)  # all elements of a times 1.5
print(a.T+b)  # b added to the transpose of a

这些numpy数组可以从磁盘保存和加载(甚至压缩)，具有大量元素的复杂计算像c一样快。

多用于科学环境。参见在这里了解更多信息。

这样如何……

>>> a = range(12)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> a[7]
6

Python称它们为列表。你可以用方括号和逗号写一个列表文字:

>>> [6,28,496,8128]
[6, 28, 496, 8128]

我有一个字符串数组，需要一个具有相同长度的布尔值的数组，初始化为True。这就是我所做的

strs = ["Hi","Bye"]
bools = [ True for s in strs ]

在Python中，这是一个非常复杂的主题。

实际回答

数组由类list表示(请参阅参考，不要将它们与发电机混合)。

看看用法示例:

# empty array
arr = []


# init with values (can contain mixed types)
arr = [1, "eels"]


# get item by index (can be negative to access end of array)
arr = [1, 2, 3, 4, 5, 6]
arr[0]  # 1
arr[-1] # 6


# get length
length = len(arr)


# supports append and insert
arr.append(8)
arr.insert(6, 7)

理论的答案

实际上，Python的list是一个实际数组的包装器，其中包含对项的引用。此外，创建底层数组时还使用了一些额外的空间。

这样做的后果是:

• 随机访问真的很便宜(arr[6653]和arr[0]一样)
• append操作是“免费的”，而有一些额外的空间
• insert操作是昂贵的

检查令人敬畏的操作复杂度表。

为了补充Lennart的答案，可以像这样创建一个数组:

from array import array
float_array = array("f",values)

其中值可以采用元组、列表或np的形式。数组，而不是数组:

values = [1,2,3]
values = (1,2,3)
values = np.array([1,2,3],'f')
# 'i' will work here too, but if array is 'i' then values have to be int
wrong_values = array('f',[1,2,3])
# TypeError: 'array.array' object is not callable

输出仍然是相同的:

print(float_array)
print(float_array[1])
print(isinstance(float_array[1],float))


# array('f', [1.0, 2.0, 3.0])
# 2.0
# True

从回答和评论来看，似乎数组 数据结构不是那么流行。不过我还是喜欢 就像人们可能更喜欢元组而不是列表一样

数组结构比list或np有更严格的规则。数组，这个可以 减少错误并使调试更容易，特别是在使用数值时 数据。< / p >

尝试将浮点数插入/追加到int数组将抛出TypeError:

values = [1,2,3]
int_array = array("i",values)
int_array.append(float(1))
# or int_array.extend([float(1)])


# TypeError: integer argument expected, got float

在数组中保留整数的值(例如索引列表) form可能因此防止“TypeError: list index must be integer, not float”，因为数组可以迭代，类似于np。数组和列表:

int_array = array('i',[1,2,3])
data = [11,22,33,44,55]
sample = []
for i in int_array:
sample.append(data[i])

烦人的是，将一个int型数组附加到一个浮点型数组将导致该int型变成一个浮点型，而不会引发异常。

np。数组也会为它的条目保留相同的数据类型，但它不会给出错误，而是会改变它的数据类型来适应新的条目(通常是double或str):

import numpy as np
numpy_int_array = np.array([1,2,3],'i')
for i in numpy_int_array:
print(type(i))
# <class 'numpy.int32'>
numpy_int_array_2 = np.append(numpy_int_array,int(1))
# still <class 'numpy.int32'>
numpy_float_array = np.append(numpy_int_array,float(1))
# <class 'numpy.float64'> for all values
numpy_str_array = np.append(numpy_int_array,"1")
# <class 'numpy.str_'> for all values
data = [11,22,33,44,55]
sample = []
for i in numpy_int_array_2:
sample.append(data[i])
# no problem here, but TypeError for the other two

在作业中也是如此。如果指定了数据类型，则np。数组将在任何可能的情况下将条目转换为该数据类型:

int_numpy_array = np.array([1,2,float(3)],'i')
# 3 becomes an int
int_numpy_array_2 = np.array([1,2,3.9],'i')
# 3.9 gets truncated to 3 (same as int(3.9))
invalid_array = np.array([1,2,"string"],'i')
# ValueError: invalid literal for int() with base 10: 'string'
# Same error as int('string')
str_numpy_array = np.array([1,2,3],'str')
print(str_numpy_array)
print([type(i) for i in str_numpy_array])
# ['1' '2' '3']
# <class 'numpy.str_'>

或者，本质上:

data = [1.2,3.4,5.6]
list_1 = np.array(data,'i').tolist()
list_2 = [int(i) for i in data]
print(list_1 == list_2)
# True

While数组将简单地给出:

invalid_array = array([1,2,3.9],'i')
# TypeError: integer argument expected, got float

因此，使用np并不是一个好主意。数组用于特定类型的命令。数组结构在这里很有用。List保留值的数据类型。

对于一些我发现相当麻烦的事情:数据类型被指定为array()中的第一个参数，但(通常)在np.array()中的第二个参数。：|

与C的关系: # EYZ0 < / p >

祝探索愉快!

注意:数组的类型化和相当严格的性质更倾向于C而不是Python，并且按照设计，Python的函数中没有许多特定于类型的约束。它的不受欢迎也在协作工作中创造了一个积极的反馈，取代它主要涉及一个额外的[int(x) for x in file]。因此，忽略数组的存在是完全可行和合理的。它不应该以任何方式阻碍我们大多数人。: D

一些贡献建议python中的数组由列表表示。这是不正确的。Python在标准库模块array "array.array()"中有array()的独立实现，因此将两者混淆是不正确的。列表在python中是列表，所以要小心使用的命名法。

list_01 = [4, 6.2, 7-2j, 'flo', 'cro']


list_01
Out[85]: [4, 6.2, (7-2j), 'flo', 'cro']

list和array.array()之间有一个非常重要的区别。虽然这两个对象都是有序序列，但array.array()是有序齐次序列，而list是非齐次序列。

JohnMachin的评论应该是真正的答案。 在我看来，所有其他答案都只是变通方法! 所以:< / p >

array=[0]*element_count

您可以创建列表并将其转换为数组，或者您可以使用numpy模块创建数组。下面是几个例子来说明这一点。Numpy还使使用多维数组变得更容易。

import numpy as np
a = np.array([1, 2, 3, 4])


#For custom inputs
a = np.array([int(x) for x in input().split()])

您还可以使用使用输入作为矩阵维数的重塑函数将该数组重塑为2X2矩阵。

mat = a.reshape(2, 2)

# This creates a list of 5000 zeros
a = [0] * 5000

您可以像使用数组一样，使用[n]符号读取和写入此列表中的任何元素。

它似乎具有与数组相同的随机访问性能。我不能说它如何分配内存，因为它还支持不同类型的混合，包括字符串和对象，如果你需要的话。