Python 组合NumPy阵列

我有两个20x100x3阵列，我想将它们组合成一个40x100x3阵列，也就是说，只需向阵列添加更多行。我对我想要的函数感到困惑：是vstack、hstack、column\u stack还是其他什么？

我相信你想要的是vstack

p=array_2
q=array_2
p=numpy.vstack([p,q])

---

最好的学习方法之一是实验，但我想说你想要

np.vstack

，尽管还有其他方法可以做同样的事情：

a = np.ones((20,100,3))
b = np.vstack((a,a)) 

print b.shape # (40,100,3)

或

编辑

请注意，在我的机器上，对于OP问题中的大小数组，我发现

np.concatenate

比

np.vstack

快2倍左右

In [172]: a = np.random.normal(size=(20,100,3))

In [173]: c = np.random.normal(size=(20,100,3))

In [174]: %timeit b = np.concatenate((a,c),axis=0)
100000 loops, best of 3: 13.3 us per loop

In [175]: %timeit b = np.vstack((a,c))
10000 loops, best of 3: 26.1 us per loop

---

也许值得一提

    np.concatenate((a1, a2, ...), axis=0) 

---

是一般形式，vstack和hstack是具体情况。我发现最简单的方法就是知道要叠加哪个维度，并将其作为np.concatenate的参数提供。

顺便说一句，还有

r\uuu

：

>>> from scipy import *
>>> a = rand(20,100,3)
>>> b = rand(20,100,3)
>>> a.shape
(20, 100, 3)
>>> b.shape
(20, 100, 3)
>>> r_[a,b].shape
(40, 100, 3)
>>> (r_[a,b] == vstack([a,b])).all()
True

---

我在r_u和vstack之间尝试了一个小基准测试，结果非常有趣：

import numpy as np

NCOLS = 10
NROWS = 2
NMATRICES = 10000

def mergeR(matrices):
    result = np.zeros([0, NCOLS])

    for m in matrices:
        result = np.r_[ result, m]

def mergeVstack(matrices):
    result = np.vstack(matrices)

def main():
    matrices = tuple( np.random.random([NROWS, NCOLS]) for i in xrange(NMATRICES) )
    mergeR(matrices)
    mergeVstack(matrices)

    return 0

if __name__ == '__main__':
    main()

然后我运行了探查器：

python -m cProfile -s cumulative np_merge_benchmark.py

结果是：

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
...
     1    0.579    0.579    4.139    4.139 np_merge_benchmark.py:21(mergeR)
...
     1    0.000    0.000    0.054    0.054 np_merge_benchmark.py:27(mergeVstack)

---

因此vstack方式快77倍

我不知道为什么我第一次访问该页面时你的答案没有显示出来+1建议首先使用vstack。请注意，文档建议现在使用

堆栈

或

串联

，并且vstack仅支持向后兼容性。请参见：我可能是，在这里很愚蠢，因为我没有太多使用timeit，但串联不会占用10倍的循环数？@Giltech，虽然timeit使用了10倍以上的循环来基准化

np.concatenate

（这似乎是自动选择的），但这里重要的数字是每个循环的时间。您应该注意系数2。您的测试用例包含6000个项目的小阵列，在我们的范围内。简单地将输入数组扩展到（2010000,3）将导致每个循环6.62毫秒，而每个循环6.38毫秒，这仍然有利于直接使用串联。因此，对于大型阵列，差异其实并不重要。@EnnoGröper good point。当性能很重要时，应该始终执行自己的基准测试/进行自己的评测。考虑到OP系统的大小，我只是建议一种特殊的方法。

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
...
     1    0.579    0.579    4.139    4.139 np_merge_benchmark.py:21(mergeR)
...
     1    0.000    0.000    0.054    0.054 np_merge_benchmark.py:27(mergeVstack)