数组的拼接

水平数组组合

通过 hstack 函数可以将两个或多个数组水平组合起来形成一个数组，那么什么叫做数组 的水平组合。现在有两个 2*3 的数组 A 和 B。
数组 A

0 1 2 
3 4 5 

数组 B

6 7 8 
9 10 11

使用 hstack 函数将两个数组水平组合的代码如下： hstack(A,B)
返回的结果：

 0 1 2 6 7 8 
 3 4 5 9 10 11 

可以看到，数组 A 和数组 B 在水平方向首尾连接了起来，形成了一个新的数组。这就是数组的水平组合。多个数组进行水平组合的效果类似。但数组水平组合必须要满足一个条 件，就是所有参与水平组合的数组的行数必须相同，否则进行水平组合会抛出异常。
垂直数组组合
通过 vstack 函数可以将两个或多个数组垂直组合起来形成一个数组，那么什么叫数组的 垂直组合呢？现在以两个 2*3 的数组 A 和 B 为例
数组 A

0 1 2
3 4 5 

数组 B

 6 7 8 
 9 10 11

使用 vstack 函数将两个数组垂直组合代码：vstack(A,B)
运行的结果是：

0 1 2 
3 4 5 
6 7 8 
9 10 11 

数组的拼接

函数	描述
concatenate	连接沿现有轴的数组序列
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下： numpy.concatenate((a1, a2, ...), axis)
参数说明：
a1, a2, …：相同类型的数组
axis：沿着它连接数组的轴，默认为 0
concatenate 实现数组的拼接

a=np.array([[1,2,3],[4,5,6]]) 
print(a) 
b=np.array([['a','b','c'],['d','e','f']]) 
print(b) 
print(np.concatenate([a,b]))
print('垂直方向拼接 相当于 vstack') 
print(np.concatenate([a,b],axis=0)) 
print('水平方向拼接 相当于 hstack') 
print(np.concatenate([a,b],axis=1)) 

运行结果:

[[1 2 3]
 [4 5 6]]
[['a' 'b' 'c']
 ['d' 'e' 'f']]
[['1' '2' '3']
 ['4' '5' '6']
 ['a' 'b' 'c']
 ['d' 'e' 'f']]
垂直方向拼接 相当于 vstack
[['1' '2' '3']
 ['4' '5' '6']
 ['a' 'b' 'c']
 ['d' 'e' 'f']]
水平方向拼接 相当于 hstack
[['1' '2' '3' 'a' 'b' 'c']
 ['4' '5' '6' 'd' 'e' 'f']]

numpy.hstack 它通过水平堆叠来生成数组。
numpy.vstack 它通过垂直堆叠来生成数组。
三维数组的拼接

import numpy as np
aa=np.arange(1,37).reshape(3,4,3)
print(aa)
bb=np.arange(101,137).reshape(3,4,3)
print(bb)
print('axis=0'*10)
print(np.concatenate((aa,bb),axis=0)) #6 4 3
print('axis=1'*10)
print(np.concatenate((aa,bb),axis=1)) #3,8,3
print('axis=2'*10)
print(np.concatenate((aa,bb),axis=2)) #3,4,6

运行结果如下:

[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]
[[13 14 15]
  [16 17 18]
  [19 20 21]
  [22 23 24]]
  [[25 26 27]
  [28 29 30]
  [31 32 33]
  [34 35 36]]]
  [[[101 102 103]
  [104 105 106]
  [107 108 109]
  [110 111 112]]
  [[113 114 115]
  [116 117 118]
  [119 120 121]
  [122 123 124]]
  [[125 126 127]
  [128 129 130]
  [131 132 133]
  [134 135 136]]]
  axis=0axis=0axis=0axis=0axis=0axis=0axis=0axis=0axis=0axis=0
  [[[  1   2   3]
  [  4   5   6]
  [  7   8   9]
  [ 10  11  12]]
   [[ 13  14  15]
  [ 16  17  18]
  [ 19  20  21]
  [ 22  23  24]]
  [[ 25  26  27]
  [ 28  29  30]
  [ 31  32  33]
  [ 34  35  36]]
   [[101 102 103]
  [104 105 106]
  [107 108 109]
  [110 111 112]]
  [[ 13  14  15]
  [ 16  17  18]
  [ 19  20  21]
  [ 22  23  24]
  [113 114 115]
  [116 117 118]
  [119 120 121]
  [122 123 124]]
   [[ 25  26  27]
  [ 28  29  30]
  [ 31  32  33]
  [ 34  35  36]
  [125 126 127]
  [128 129 130]
  [131 132 133]
  [134 135 136]]]
axis=2axis=2axis=2axis=2axis=2axis=2axis=2axis=2axis=2axis=2
[[[  1   2   3 101 102 103]
  [  4   5   6 104 105 106]
  [  7   8   9 107 108 109]
  [ 10  11  12 110 111 112]]
   [[ 13  14  15 113 114 115]
  [ 16  17  18 116 117 118]
  [ 19  20  21 119 120 121]
  [ 22  23  24 122 123 124]]
  [[ 25  26  27 125 126 127]
  [ 28  29  30 128 129 130]
  [ 31  32  33 131 132 133]
  [ 34  35  36 134 135 136]]]

axis=0 可以使用 vstack 替换
axis=1 可以使用 hstack 替换
axis=2 可以使用 dstack 替换

数组的分隔
split 分隔
numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明： ary：被分割的数组 indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的 位置。 axis：沿着哪个维度进行切向，默认为 0，横向切分。为 1 时，纵向切分。
split 分隔一维数组

import numpy as np 
x=np.arange(1,9) 
a=np.split(x,4) 
print(a) 
print(a[0]) 
print(a[1]) 
print(a[2]) 
print(a[3]) #传递数组进行分隔 
b=np.split(x,[3,5]) 
print(b) 

运行结果如下:

[array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
[1 2]
[3 4]
[5 6]
[7 8]
[array([1, 2, 3]), array([4, 5]), array([6, 7, 8])]

水平分隔
分隔数组是组合数组的逆过程，与组合数组一样，分隔数组也分为水平分隔数组和垂直 分隔数组。水平分隔数组与水平组合数组对应。水平组合数组是将两个或多个数组水平进行 收尾相接，而水平分隔数组是将已经水平组合到一起的数组再分开。
使用 hsplit 函数可以水平分隔数组，该函数有两个参数，第 1 个参数表示待分隔的数组， 第 2 个参数表示要将数组水平分隔成几个小数组，现在先来看一个例子。下面是一个 2*6 的二维数组 X
数组 X

1 2 3 4 5 6 
7 8 9 10 11 12

使用如下代码对 X 数组进行分隔
np.hsplit(X,2) 分隔的结果如下：

1 2 3    4 5 6 
7 8 9    10 11 12

很明显，将数组 X 分隔成了列数相同的两个数组。现在使用下面的代码重新对数组 X 进行 分隔

np.hsplit(X,3)

分隔的结果如下：

1 2    3 4    5 6 
7 8    9 10  11 12

现在讲数组 X 分隔成了 3 个列数都为 2 的数组，但要是使用 hsplit(X,4)分隔数组 X 就会 抛出异常，这是因为数组 X 是没有办法被分隔成列数相同的 4 个数组的，所以使用 hsplit 函数分隔数组的一个规则就是第 2 个参数值必须可以整除待分隔数组的列数。
垂直分隔数组
垂直分隔数组是垂直组合数组的逆过程。垂直组合数组是将两个或多个数组垂直进行首 尾相接，而垂直分隔数组是将已经垂直组合到一起的数组再分开。
使用 vsplit 函数可以垂直分隔数组，该函数有两个参数，第 1 个参数表示待分隔的数组， 第 2 个参数表示将数组垂直分隔成几个小数组。示例如下，一个 4*3 的二维数组 X。
数组 X

 1 2 3
  4 5 6 
  7 8 9 
10 11 12   

现在使用如下的代码对数组 X 进行分隔：
vsplit(X,2)
分隔后的结果如下：

 1 2 3 
 4 5 6
 7 8 9 
 10 11 12

很明显，将数组 X 分隔成了行数相同的两个数组。现在使用下面的代码重新对数组 X 进行分隔。 vsplit(X,4) 分隔后的结果：

0 1 2 
1 2 3 
2 5 6 
7 8 9 
10 11 12