numpy基础属性方法随机整理（四）---数组组合和分割 vstack /hstack / row_stack / column_stack / dstack /v[sd]split

数组组合类型：

1. 垂直组合
np.vstack((up,down)) up, down 表示数据在上还是在下，类似于堆栈
2. 水平组合
np.hstack((left, right)) left right 表示数据在左还是在右
3. 行组合（对象：一维数组）
np.row_stack((up,down))
4. 列组合（对象：一维数组）
np.column_stack((left,right))
5. 深度组合
np.dstack((a,b))
6.垂直分割(vstack 与 vsplit 操作可逆)
u,m,d = np.vsplit(v,3) # 3表示分割后的个数
7.水平分割(hstack 与 hsplit 操作可逆)
l,m,r = np.hsplit(v,3)
8.深度分割 ——–(操作不可逆)
x,y = np.dsplit(d,2)
可逆需进行 x.T[0].T 的操作

注：参数为tuple

直接上代码，如下：

# -*- coding: utf-8 -*-
"""
Spyder Editor

This is a temporary script file.
"""

import numpy as np

a = np.arange(1, 19).reshape(3, 6)
b = a * 10
c = a.ravel()        # 视图变维
d = b.flatten()      # 复制变维
print('a:', a, '\n', 'b:', b, '\n', 'c:', c, '\n', 'd:', d, '\n')
e = np.vstack((a, b))  # 垂直组合，参数为元组 (a,b)
f = np.hstack((a, b))   # 水平组合
g = np.row_stack((c, d))        # 行组合，适用对象为一维数组
h = np.column_stack((c, d))  # 列组合，适用对象为一维数组
print('e1:', e, '\n', 'f:', f, '\n', 'g:', g, '\n', 'h:', h, '\n')
k = np.dstack((a, b))       # 深度组合
print('深度组合dstack:','\n', k)
print('e:','\n',e)
u,mv,d = np.vsplit(e,3)
print('\n','垂直拆分：', '\n', u,mv,d)   # vstack与 vsplit操作可逆
l,mh,r = np.hsplit(e,3)                 # hstack 与 hsplit操作可逆
print('\n','水平拆分：','\n',l,mh,r)
print('深度拆分：(不可逆)')              # 不可逆，dstack 与 dsplit 操作不可逆
m, n = np.dsplit(k,2)
print(k)
print('m:',m.shape,'\n',m,'\n','n:',n.shape,'\n',n)
print('\n','\\\\\\\\\\\\')
print('m.T.shape:',m.T.shape,'\n',m.transpose(), '\n','m.T[0].T.shape:',m.T[0].T.shape,'\n',m.T[0].T)
print(a == m.T[0].T)            # 说明深度拆分不可逆，需进行 “m.T[0].T” 操作后才能复原

output:

a: [[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]] 
 b: [[ 10  20  30  40  50  60]
 [ 70  80  90 100 110 120]
 [130 140 150 160 170 180]] 
 c: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18] 
 d: [ 10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180] 

e1: [[  1   2   3   4   5   6]
 [  7   8   9  10  11  12]
 [ 13  14  15  16  17  18]
 [ 10  20  30  40  50  60]
 [ 70  80  90 100 110 120]
 [130 140 150 160 170 180]] 
 f: [[  1   2   3   4   5   6  10  20  30  40  50  60]
 [  7   8   9  10  11  12  70  80  90 100 110 120]
 [ 13  14  15  16  17  18 130 140 150 160 170 180]] 
 g: [[  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18]
 [ 10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180]] 
 h: [[  1  10]
 [  2  20]
 [  3  30]
 [  4  40]
 [  5  50]
 [  6  60]
 [  7  70]
 [  8  80]
 [  9  90]
 [ 10 100]
 [ 11 110]
 [ 12 120]
 [ 13 130]
 [ 14 140]
 [ 15 150]
 [ 16 160]
 [ 17 170]
 [ 18 180]] 

深度组合dstack: 
 [[[  1  10]
  [  2  20]
  [  3  30]
  [  4  40]
  [  5  50]
  [  6  60]]

 [[  7  70]
  [  8  80]
  [  9  90]
  [ 10 100]
  [ 11 110]
  [ 12 120]]

 [[ 13 130]
  [ 14 140]
  [ 15 150]
  [ 16 160]
  [ 17 170]
  [ 18 180]]]
e: 
 [[  1   2   3   4   5   6]
 [  7   8   9  10  11  12]
 [ 13  14  15  16  17  18]
 [ 10  20  30  40  50  60]
 [ 70  80  90 100 110 120]
 [130 140 150 160 170 180]]

 垂直拆分： 
 [[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]] [[13 14 15 16 17 18]
 [10 20 30 40 50 60]] [[ 70  80  90 100 110 120]
 [130 140 150 160 170 180]]

 水平拆分： 
 [[  1   2]
 [  7   8]
 [ 13  14]
 [ 10  20]
 [ 70  80]
 [130 140]] [[  3   4]
 [  9  10]
 [ 15  16]
 [ 30  40]
 [ 90 100]
 [150 160]] [[  5   6]
 [ 11  12]
 [ 17  18]
 [ 50  60]
 [110 120]
 [170 180]]
深度拆分：(不可逆)
[[[  1  10]
  [  2  20]
  [  3  30]
  [  4  40]
  [  5  50]
  [  6  60]]

 [[  7  70]
  [  8  80]
  [  9  90]
  [ 10 100]
  [ 11 110]
  [ 12 120]]

 [[ 13 130]
  [ 14 140]
  [ 15 150]
  [ 16 160]
  [ 17 170]
  [ 18 180]]]
m: (3, 6, 1) 
 [[[ 1]
  [ 2]
  [ 3]
  [ 4]
  [ 5]
  [ 6]]

 [[ 7]
  [ 8]
  [ 9]
  [10]
  [11]
  [12]]

 [[13]
  [14]
  [15]
  [16]
  [17]
  [18]]] 
 n: (3, 6, 1) 
 [[[ 10]
  [ 20]
  [ 30]
  [ 40]
  [ 50]
  [ 60]]

 [[ 70]
  [ 80]
  [ 90]
  [100]
  [110]
  [120]]

 [[130]
  [140]
  [150]
  [160]
  [170]
  [180]]]

 \\\\\\
m.T.shape: (1, 6, 3) 
 [[[ 1  7 13]
  [ 2  8 14]
  [ 3  9 15]
  [ 4 10 16]
  [ 5 11 17]
  [ 6 12 18]]] 
 m.T[0].T.shape: (3, 6) 
 [[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]]
[[ True  True  True  True  True  True]
 [ True  True  True  True  True  True]
 [ True  True  True  True  True  True]]

注：print(a == m.T[0].T)的结果 说明深度拆分不可逆，需进行 “m.T[0].T” 操作后才能复原