[Numpy]stack(), hstack(), vstack(), concatenate()

部分资料来源于网络，仅做个人学习之用

目录

0. axis取值

1. stack()

2. hstack()

3. vstack()

4. concatenate()

---

0. axis取值

在numpy中数组都有着[ ]标记，则axis=0对应着最外层的[ ]，axis=1对应第二外层的[ ]，……，axis=n对应第n外层的[ ]。

sum()   不传参：所有元素的总和

            有参数axis：将按照指定axis进行对应元素内求和

（1）axis = 0：对最外层[ ]里的最大单位块做块与块之间的运算, 同时移除最外层[ ]：

a= np.array([1,2,3])    
a.sum(axis = 0)
>>>6

因为只有一层[ ]，所以直接对1，2，3做运算
加法后本应是[6]，但是移除最外层[ ]后，[ ]不存在了，所以返回的是6。

a= np.array([[1,2],[3,4]])  
a.sum(axis = 0)
>>>array([4, 6])

有两层[ ]，最外层[ ]里的最大单位块分别为[1,2]，[3,4]，对这两个单位块做块与块之间的运算，[1,2]+[3,4] = [4, 6]；
做完加法后本应是[[4, 6]]，但是移除最外层[ ]后，原来的两层[ ]变成一层[ ],所以返回结果为 [4, 6]。

a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
a.sum(axis = 0)
>>>array([[12, 14], [16, 18]])

有三层[ ]，最外层[ ]里的最大单位块分别为[[1,2],[3,4]]，[[11,12],[13,14]]，对这两个单位块做块与块之间的运算，[[1,2],[3,4]] + [[11,12],[13,14]] = [[12, 14], [16, 18]]；
做完加法后本应是[[[12, 14], [16, 18]]]，但是移除最外层[ ]后，原来的三层[ ]变成两层[ ],所以返回结果为[[12, 14], [16, 18]]；

（2）axis= 1：对第二外层[]里的最大单位块做块与块之间的运算, 同时移除第二外层[]：

a= np.array([1,2,3])    
a.sum(axis = 1)
>>>ValueError: 'axis' entry is out of bounds

因为只有一层[ ]，axis取值只能为0，否则报错

a= np.array([[1,2],[3,4]])  
a.sum(axis = 1)
>>>array([3, 7])

a=np.array([[2],[3]])
a.sum(axis=1)
>>> array([2, 3])

有两层[ ]，第二外层[ ]里的最大单位块有两组（因为有两个第二外层[ ]），第一组是1，2，第二组是3，4，分别对这两个单位块做块与块之间的运算，第一组结果为1+2=3，第二组结果为3+4=7；
做完加法后本应是[[3],[7]]，但是 移除第二外层[ ] 后，原来的两层[ ]变成一层[ ],所以返回结果为[3, 7]。
对于第二个例子，在第二层[ ]中，第一个[ ]里的元素只有一个2，第二个[ ]里的元素只有一个3，都没有可以相加的其他元素，因此返回本身，最后去掉第二层[ ]，为[2,3]

a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
a.sum(axis = 1)
>>>array([[ 4,  6], [24, 26]])

有三层[ ]，第二外层[ ]里的最大单位块有两组（因为有两个第二外层[ ]），第一组是[1,2],[3,4]，第二组是[11,12],[13,14]，分别对这两个单位块做块与块之间的运算，第一组结果为[1,2]+[3,4] = [ 4, 6]，第二组结果为[11,12]+[13,14] = [24, 26]；
做完加法后本应是[[[ 4, 6]], [[24, 26]]]，但是 移除第二外层[ ] 后，原来的三层[]变成两层[],所以返回结果为[[ 4, 6], [24, 26]]

1. stack()

按照指定的轴对数组序列进行联结。

格式：numpy.stack(arrays, axis=0, out=None)
arrays :数组序列，数组的形状（shape）必须相同

import numpy as np
a=[[1,2,3],   [4,5,6]]
b=[[1,2,3],   [4,5,6]]
c=[[1,2,3],   [4,5,6]]
print("a=",a)
print("b=",b)
print("c=",c)
print('"axis=0":\n',np.stack((a,b,c),axis=0))
print('"axis=1":\n',np.stack((a,b,c),axis=1))
print('"axis=2":\n',np.stack((a,b,c),axis=2))

                                                           

（1）axes=0：以0维度的元素为单位

元素：[[1 2 3] [4 5 6]]——0、[[1 2 3] [4 5 6]]——1、[[1 2 3] [4 5 6]]——2

按下标[0,1,2]顺序排（堆）起来即可，结果shape为 (3, 2, 3)  即第一维度有三个元素，第二维度有2个元素，第三纬度有3个元素

（2）axes=1：以1维度的元素为单位

元素：[1 2 3]——0、[4 5 6]——1、[1 2 3]——0、[4 5 6]——1、[1 2 3]——0、[4 5 6]——1

按下标[[0,0,0]，[1,1,1]]进行堆叠即可，结果的shape为 (2, 3, 3)

（3）axes=2：以2维度的元素为单位

元素：1——0、2——1、3——2、4——3、5——4、6——5、1——0、2——1、3——2、4——3、5——4、6——5、1——0、2——1、3——2、4——3、5——4、6——5

按下标 [[[0,0,0]，[1,1,1]，[2,2,2]]，[[3,3,3]，[4,4,4]，[5,5,5]]] 进行堆叠，结果的shape为 (2, 3, 3)

---

2. hstack()

水平(按列顺序)把数组给堆叠起来，等价于np.concatenate（tup,axis=1）

格式：numpy.hstack(tup)
tup：元组，列表，或者numpy数组，返回结果为numpy的数组

The arrays must have the same shape along all but the second axis,except 1-D arrays which can be any length.

（1）一维数组的堆叠可以是不同长度

b = np.hstack(([1,3,5], [2,5,6,7,8]))
print(b)
>>>[1 3 5 2 5 6 7 8]

（2）其它数组堆叠时，除了第二个轴的长度（[1, 2]与[7]的长度）可以不同外，其它轴的长度（即元素个数 ，如下例所示均为两个元素）必须相同。

a = np.array([[1, 2], [3, 4]])
b = np.array([[7], [5]])
print(np.hstack((a, b)))
>>>[[1 2 7]
    [3 4 5]]

3. vstack()

格式：numpy.vstack(tup)

tup：元组，列表，或者numpy数组，返回结果为numpy的数组

等价于：np.concatenate(tup,axis=0) 

The arrays must have the same shape along all but the first axis.1-D arrays must have the same length.

（1）一维数组进行堆叠，则数组长度必须相同

#1
print(np.vstack([1,2,3]))
>>>[[1]
    [2]
    [3]]
#2
a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
np.vstack((a,b))
>>>array([[1, 2, 3],
          [2, 3, 4]])
#3
az = np.array([1, 2])
b = np.array([[2, 3],[0]]) # 将列表视为一个元素，因此一维数组的长度相等
print(np.vstack((a,b)))
>>>[[1 2]
    [list([2, 3]) list([0])]]
#4
az = np.array([1, 2])
b = np.array([2, 3])  # 两个长度相等的一维数组，若b = np.array([2, 4, 3])则报错 
print(np.vstack((a,b)))
>>>[[1 2]
    [2 3]]

（2）其它数组堆叠时，除数组第一个轴的长度可以不同，其它轴长度必须一样。

a = np.array([[1, 8, 2]])
b = np.array([[2, 3, 8],[2, 0, 0]])  
"""
二维数组，虽然元素个数不一样，但单个元素的长度相同
若b = np.array([[2, 3, 8],[2, 0, 0], [2]) 则报错, 因为单个元素的长度不同
"""
print(np.vstack((a,b)))
>>>[[1 8 2]
    [2 3 8]
    [2 0 0]]

4. concatenate()

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

将具有相同结构的array序列结合成一个array

axis是拼接方向，0为横轴，1为纵轴。