问题描述：

我想创建一个空数组并向其中逐个添加项目。

xs = []
for item in data:
    xs.append(item)

我可以将这种列表样式符号与NumPy数组一起使用吗？

解决方案 1：

这对于高效使用 NumPy 来说是一种错误的思维模式。NumPy 数组存储在连续的内存块中。要将行或列添加到现有数组，需要将整个数组复制到新的内存块中，从而为新元素的存储留下空隙。如果反复执行此操作，效率会非常低。

不要添加行，而是分配一个适当大小的数组，然后逐行分配给它：

>>> import numpy as np

>>> a = np.zeros(shape=(3, 2))
>>> a
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])

>>> a[0] = [1, 2]
>>> a[1] = [3, 4]
>>> a[2] = [5, 6]

>>> a
array([[ 1.,  2.],
       [ 3.,  4.],
       [ 5.,  6.]])

解决方案 2：

NumPy 数组是一种与列表截然不同的数据结构，其设计用途也各不相同。使用数组hstack可能会非常低效……每次调用它时，现有数组中的所有数据都会被复制到一个新数组中。（该append函数也会出现同样的问题。）如果您想一次构建一列矩阵，最好先将其保存在列表中，直到构建完成，然后再将其转换为数组。

例如

mylist = []
for item in data:
    mylist.append(item)
mat = numpy.array(mylist)

item可以是列表、数组或任何可迭代对象，只要每个对象item包含相同数量的元素即可。

在这个特殊情况下（data是某个保存矩阵列的可迭代对象），你可以简单地使用

mat = numpy.array(data)

（另请注意，用作list变量名可能不是一个好习惯，因为它会用该名称掩盖内置类型，从而可能导致错误。）

编辑：

如果由于某种原因您确实想要创建一个空数组，那么您可以使用 numpy.array([])，但这很少有用！

解决方案 3：

要在 NumPy 中创建一个空的多维数组（例如，用于存储矩阵的二维数组m*n），如果您不知道m要附加多少行，并且不关心 Stephen Simmons 提到的计算成本（即在每次附加时重新构建数组），您可以将要附加到的维度压缩为 0 X = np.empty(shape=[0, n])：。

这样你就可以使用例如（这里m = 5我们假设在创建空矩阵时我们不知道，并且n = 2）：

import numpy as np

n = 2
X = np.empty(shape=[0, n])

for i in range(5):
    for j  in range(2):
        X = np.append(X, [[i, j]], axis=0)

print X

这将为您提供：

[[ 0.  0.]
 [ 0.  1.]
 [ 1.  0.]
 [ 1.  1.]
 [ 2.  0.]
 [ 2.  1.]
 [ 3.  0.]
 [ 3.  1.]
 [ 4.  0.]
 [ 4.  1.]]

解决方案 4：

我对此进行了大量研究，因为我需要在我的学校项目之一中使用 numpy.array 作为集合，并且需要将其初始化为空...我在 Stack Overflow 上没有找到任何相关的答案，所以我开始涂鸦一些东西。

# Initialize your variable as an empty list first
In [32]: x=[]
# and now cast it as a numpy ndarray
In [33]: x=np.array(x)

结果将是：

In [34]: x
Out[34]: array([], dtype=float64)

因此，您可以直接初始化 np 数组，如下所示：

In [36]: x= np.array([], dtype=np.float64)

我希望这有帮助。

解决方案 5：

要创建一个空的 NumPy 数组而不定义其形状，您可以执行以下操作：

arr = np.array([])

第一个是首选，因为你知道你将使用它作为 NumPy 数组。NumPynp.ndarray随后会将其转换为类型，而无需额外的[]“维度”。

要向数组中添加新元素，我们可以执行以下操作：

arr = np.append(arr, 'new element')

请注意，在 python 的背景下，不存在没有定义其形状的数组。正如@hpaulj 提到的，这也会形成一个单秩数组。

解决方案 6：

您可以使用 append 函数。对于行：

>>> from numpy import *
>>> a = array([10,20,30])
>>> append(a, [[1,2,3]], axis=0)
array([[10, 20, 30],      
       [1, 2, 3]])

对于列：

>>> append(a, [[15],[15]], axis=1)
array([[10, 20, 30, 15],      
       [1, 2, 3, 15]])

编辑

当然，正如其他答案中提到的那样，除非你每次向矩阵/数组附加某些内容时都对其进行某些处理（例如反转），否则我只会创建一个列表，将其附加到它然后将其转换为数组。

解决方案 7：

这里有一些解决方法，使 numpys 看起来更像列表

np_arr = np.array([])
np_arr = np.append(np_arr , 2)
np_arr = np.append(np_arr , 24)
print(np_arr)

输出：数组（[ 2., 24.]）

解决方案 8：

如果您确实不知道数组的最终大小，您可以像这样增加数组的大小：

my_arr = numpy.zeros((0,5))
for i in range(3):
    my_arr=numpy.concatenate( ( my_arr, numpy.ones((1,5)) ) )
print(my_arr)

[[ 1.  1.  1.  1.  1.]  [ 1.  1.  1.  1.  1.]  [ 1.  1.  1.  1.  1.]]

• 注意0第一行。

• numpy.append是另一个选项。它调用numpy.concatenate。

解决方案 9：

您可以应用它来构建任何类型的数组，例如零：

a = range(5)
a = [i*0 for i in a]
print a 
[0, 0, 0, 0, 0]

解决方案 10：

创建可以接受数组的空数组的另一种简单方法是：

import numpy as np
np.empty((2,3), dtype=object)

解决方案 11：

根据您的用途，您可能需要指定数据类型（请参阅“dtype”）。

例如，要创建一个 8 位值的二维数组（适合用作单色图像）：

myarray = numpy.empty(shape=(H,W),dtype='u1')

对于 RGB 图像，在形状中包含颜色通道的数量：shape=(H,W,3)

您可能还想考虑使用 进行零初始化，numpy.zeros而不是使用。请参阅此处的numpy.empty注释。

解决方案 12：

我认为您想用列表处理大部分工作，然后将结果用作矩阵。也许这是一种方法；

ur_list = []
for col in columns:
    ur_list.append(list(col))

mat = np.matrix(ur_list)

解决方案 13：

我认为你可以创建空的 numpy 数组，例如：

>>> import numpy as np
>>> empty_array= np.zeros(0)
>>> empty_array
array([], dtype=float64)
>>> empty_array.shape
(0,)

当你想在循环中附加 numpy 数组时，这种格式很有用。

解决方案 14：

也许您正在寻找的是这样的：

x=np.array(0)

通过这种方式，你可以创建一个没有任何元素的数组。它类似于：

x=[]

这样，您将能够提前将新元素附加到数组中。

解决方案 15：

最简单的方法

输入：

import numpy as np
data = np.zeros((0, 0), dtype=float)   # (rows,cols)
data.shape

输出：

（0，0）

输入：

for i in range(n_files):
     data = np.append(data, new_data, axis = 0)

解决方案 16：

在需要添加数组的一般情况下，最好使用 vstack。例如，假设您生成批次并对其进行累积。

import numpy as np
embeddings = np.empty((0, 768), dtype=np.float32)
for i in range(10):
    batch = generate() # shape: (64, 768)
    embeddings = np.vstack((embeddings, batch))

解决方案 17：

如果数组是浮点型，我倾向于使用一个全是 NaN 值的数组，而不是使用zeros或empty数组。这样，如果任何元素由于某种原因未被赋值，就不会出现零或其他值混入的情况。

data = [1.0, 2.0, 3.0]
xs = np.full_like(data, np.nan)
for i, item in enumerate(data):
    xs[i] = item