将空行插入或附加到numpy数组

有一些引用使用

np.append

添加到初始空数组，例如

相反，我的问题是如何在数组的末尾分配额外的空空间，以便以后可以将其分配给

例如：

# Inefficient: The data in new_rows gets copied twice.
array = np.arange(6).reshape(2, 3)
new_rows = np.square(array)
new = np.concatenate((array, new_rows), axis=0)

# Instead, we would like something like the following:

def append_new_empty_rows(array, num_rows):
  new_rows = np.empty_like(array, shape=(num_rows, array.shape[1]))
  return np.concatenate((array, new_rows), axis=0)

array = np.arange(6).reshape(2, 3)
new = append_new_empty_rows(array, 2)
np.square(array[:2], out=new[2:])

但是，

np.concatenate（）

可能仍然复制空数据数组？

---

是否有类似于

np.append\u empty（）

？

的东西，为什么不按如下方式执行：

array = np.arange(6).reshape(2, 3)
n_rows = 4
new = np.vstack([array, np.zeros((n_rows, array.shape[1]) )])

新的
数组如下所示：

array([[0., 1., 2.],
   [3., 4., 5.],
   [0., 0., 0.],
   [0., 0., 0.],
   [0., 0., 0.],
   [0., 0., 0.]])

如果您想节省一些空间，那么您应该考虑使用<代码> >级联ATS/<代码>提供的<代码>输出>代码>参数。所以它是这样的：
array = np.arange(6).reshape(2, 3)
n_rows = 4
np.concatenate([array, np.zeros((n_rows, array.shape[1]))], out=array)

如您所见，唯一的赋值是
array
，没有创建任何副本。它会覆盖数组，而不是…
以下是您的操作：

制作一个数组，该数组对于两个部分都足够大<代码>np.零
避免了任何我们正在节省内存或工作的错觉

In [15]: arr1 = np.zeros((4,3), int)
In [16]: arr1
Out[16]: 
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

现在将初始值（2,3）复制到
arr1
的一部分：

In [17]: arr1[:2] = arr
In [18]: arr1
Out[18]: 
array([[0, 1, 2],
       [3, 4, 5],
       [0, 0, 0],
       [0, 0, 0]])

并使用
out
将平方值复制到第二部分

In [19]: np.square(arr[:2], out=arr1[2:])
Out[19]: 
array([[ 0,  1,  4],
       [ 9, 16, 25]])

In [21]: arr1
Out[21]: 
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 0,  1,  4],
       [ 9, 16, 25]])

我看不出与以下内容相比，这会节省任何精力或内存：

In [22]: np.concatenate((arr, np.square(arr)), axis=0)
Out[22]: 
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 0,  1,  4],
       [ 9, 16, 25]])

连接
，封面下必须制作大小合适的结果数组，并将片段复制到其中。如果您想要一个同时包含
arr
和
np.square（arr）
的数组，我发现最快的解决方案是创建一个空的较大的数组，然后将输入数组复制到其初始行中：

shape = (1000, 1000)
array = np.ones(shape)
new_shape = (2000, 1000)

def version1():  # Uses np.concatenate().
  new_rows = np.square(array)
  return np.concatenate((array, new_rows), axis=0)

def version2():  # Initializes new array using np.zeros().
  new = np.zeros(new_shape)
  new[:shape[0]] = array
  np.square(array, out=new[shape[0]:])
  return new

def append_new_empty_rows(array, num_rows):
  new = np.empty((array.shape[0] + num_rows, array.shape[1]))
  new[:array.shape[0]] = array
  return new

def version3():  # Initializes new array using np.empty().
  new = append_new_empty_rows(array, num_rows=array.shape[0])
  np.square(array, out=new[array.shape[0]:])
  return new

assert np.all(version1() == version2())
assert np.all(version1() == version3())

%timeit version1()  # 4.34 ms per loop
%timeit version2()  # 3.15 ms per loop
%timeit version3()  # 2.24 ms per loop

小心，
np.empty
生成一个全新的数组。它类似于np.zero，只是元素值不可预测。你使用它并没有节省任何内存或副本。那个llink有很多错误的答案。唯一好的方法是使用list append，并在末尾创建一个数组。最后一个块会引发ValueError。外面的
不够大。我喜欢这个方向。但是，最好使用
np.empty（）
分配
arr1
，以保存初始化数组的工作，因为数组的两个部分将只写入一次？否则，数组首先用零写入，然后用最终数据再次覆盖。（这就是
np.empty（）
的动机）我发现时差很小，不值得它引起混乱。