numpy.concatenate((a1, a2, ...), axis=0, out=None)

参数axis默认值是0，标识按照行来拼接，如果设置为None，那么所有的数组将展开为一维，并拼接在一起。

对二维数组进行拼接

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[7, 8, 9], [10, 11, 12]])
z = np.concatenate([x, y], axis=0)
print(z)
# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]
z = np.concatenate([x, y], axis=1)
print(z)
# [[ 1  2  3  7  8  9]
#  [ 4  5  6 10 11 12]]

二，堆叠，沿着新加入数组

np.stack的作用是沿着新的轴堆叠一个数组：

沿新轴：默认是axis=0

加入数组是指：新生成的数组会比用来进行拼接的原数组多一个维度.

一维数组相当于是1行N列的数组，当使用column_stack()时，该一维数组作为一个新列；当使用hstack()函数时，为原始数组新增N列；当使用vstack()函数时，为原始数组新增1行。

1，把一维数组作为列添加到二维数组中

tup是一个数组的序列，按照列堆叠时，相当于二维数组新增一列；按照行堆叠时，相当于增加一列行：

numpy.column_stack(tup)
numpy.row_stack(tup)

举个例子，把两个一维数组按照行/列堆叠成一个二维数组：

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.row_stack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])
>>> np.column_stack((a,b))
array([[1, 4],
       [2, 5],
       [3, 6]])

2，按维度堆叠数组

按列对原始数组进水平（horizontally ，column），垂直（vertically ，row）或者深度（depth,third asix）扩展，参数tup是数组的序列，参数axis表示沿着这个轴。

numpy.stack(arrays, axis=0)
numpy.hstack(tup)
numpy.vstack(tup)
numpy.dstack(tup)

举个例子，分别对数组进行列堆叠、水平堆叠和垂直堆叠：

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> np.dstack((a,b))
array([[[1, 4],
        [2, 5],
        [3, 6]]])

例子 1 ，对于两个一维数组，堆叠之后，变成一个二维数组：

x = np.array([1, 2, 3])
y = np.array([7, 8, 9])
z = np.stack([x, y]) # axis=0
print(z.shape)  # (2, 3)
print(z)
# [[1 2 3]
#  [7 8 9]]
z = np.stack([x, y], axis=1)
print(z.shape)  # (3, 2)
print(z)
# [[1 7]
#  [2 8]
#  [3 9]]

解释堆叠的过程：

沿着行来堆叠数组是指分别取出两个数组的一行，作为新的一列；依次类推。

沿着列来堆叠数组是指分别取出两个数组的一列，作为新的一行；依次类推。

例子2， 对于两个二维数组进行堆叠，会变成一个三维数组。

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[7, 8, 9], [10, 11, 12]])
z = np.stack([x, y], axis=0)
print(z.shape)  # (2,2,3)
print(z)
#[[[ 1  2  3]
#  [ 4  5  6]]
# [[ 7  8  9]
#  [10 11 12]]]
z = np.stack([x, y], axis=1)
print(z.shape)  # (2, 2, 3)
print(z)
# [[[ 1  2  3]
#   [ 7  8  9]]
#  [[ 4  5  6]
#   [10 11 12]]]
z = np.stack([x, y], axis=2)
print(z.shape)  # (2, 3, 2)
print(z)
# [[[ 1  7]
#   [ 2  8]
#   [ 3  9]]
#  [[ 4 10]
#   [ 5 11]
#   [ 6 12]]]

解释堆叠的过程：可以把二维数组看作是“一维数组”，这个“一维数组”只有一行，列是一个数组。

举例：新的一维数组只有两个列：[ 1 2 3]，[ 4 5 6]，这两列构成一行。

沿着行来堆叠数组的过程是：分别取出“一维数组”的 行（行是一个二维数组） ，作为新的一行，堆叠在一起。

沿着列来堆叠数组的过程是：分别取出“一维数组”的 列（列是一维数组级别） ，作为新的一行，堆叠在一起。

沿着深度类堆叠数组的过程是：分别取出“一维数组”的列的 元素（元素级别） ，作为新的深度，堆叠在一起。

把一个数组拆分成一个或多个子数组，作为原始数组的视图。

numpy.split(ary, indices_or_sections, axis=0)
numpy.vsplit(ary, indices_or_sections)
numpy.hsplit(ary, indices_or_sections)

参数注释：

indices_or_sections：int或一维数组，

如果indexs_or_sections是整数N，则该数组将沿轴分为N个相等的数组。如果无法进行此类拆分，则会引发错误。

如果indexs_or_sections是一维有序的整数数组（数组的元素是特定的位置序号，即索引，从0开始），那么沿轴在相应的位置处拆分该数组。如果沿轴的索引超出数组的维数，那么将相应返回一个空的子数组。

x = np.array([[11, 12, 13, 14],
              [16, 17, 18, 19],
              [21, 22, 23, 24]])
y = np.split(x, [1, 3])
print(y)
# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],
#        [21, 22, 23, 24]]), array([], shape=(0, 4), dtype=int32)]
y = np.split(x, [1, 3], axis=1)
print(y)
# [array([[11],
#        [16],
#        [21]]), array([[12, 13],
#        [17, 18],
#        [22, 23]]), array([[14],
#        [19],
#        [24]])]

参考文档：