1. numpy中axis取值的说明

axis的用法了解后，更容易理解stack()函数。
axis: 0,1,2,3,…是从外开始剥，-n,-n+1,…,-3,-2,-1是从里开始剥。

为了方便下面的理解，可以这样看待：在numpy中数组都有着[ ]标记，则axis=0对应着最外层的[ ]，axis=1对应第二外层的[ ]，以此类推，axis=n对应第n外层的[ ]。

下面开始从axis=0，axis=1这两个例子开始，使用numpy.ndarray.sum()
函数，深入透彻的理解numpy中axis的用法。

numpy.ndarray.sum()

  • axis=None时，默认为对所有元素求值

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

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

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

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

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

  1. a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
  2. a.sum(axis = 0)
  3. >>>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]]；

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

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

因为只有一层[ ]，axis取值只有一个，为0

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

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

  1. a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
  2. a.sum(axis = 1)
  3. >>>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]]


axis = 2,3，4，5也如此分析

  1. >>> a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
  2. >>> a.sum(axis=2)
  3. array([[ 3,  7],
  4.        [23, 27]])

2. stack()函数

函数原型为：stack(arrays,axis=0)
主要的参数有两个

一个是arrays，也就是用来作为堆叠的数组，要求形状维度必须相等
第二个参数为axis也就是指定依照哪个维度进行堆叠（axis默认是0）
理解了axis的用法也就能理解是根据什么来进行堆叠了，找到要堆叠的元素的维度，然后对应位置的元素堆叠起来即可

例1

  1. >>> a=[[1,2,3],
  2. ...    [4,5,6]]
  3. >>> a
  4. [[1, 2, 3], [4, 5, 6]]
  5. >>> a[1][1]
  6. 5
  7. >>> c=np.stack(a,axis=0) #axis=0表示将最外层[ ]里，只有两个元素[1, 2, 3],[4, 5, 6]，直接堆叠
  8. >>> c
  9. array([[1, 2, 3],
  10.        [4, 5, 6]])
  11. >>> c[1][1]
  12. 5
  13. >>> c=np.stack(a,axis=1) #axis=1则看第二层的[ ]，每个第二层的[ ]都有三个元素1,2,3和4,5,6，因此对应元素就行堆叠
  14. >>> c
  15. array([[1, 4],
  16.        [2, 5],
  17.        [3, 6]])
  19. >>> type(c)
  20. <class 'numpy.ndarray'>

例2

  1. >>> a=[1,2,3,4]
  2. >>> b=[5,6,7,8]
  3. >>> c=[9,10,11,12]
  4. >>> d=np.stack((a,b,c),axis=0) #(a,b,c)表示将a,b,c合起来看作一个数组，分析同上
  5. >>> d
  6. array([[ 1,  2,  3,  4],
  7.        [ 5,  6,  7,  8],
  8.        [ 9, 10, 11, 12]])
  9. >>> 
  10. KeyboardInterrupt
  11. >>> d=np.stack((a,b,c),axis=1)
  12. >>> d
  13. array([[ 1,  5,  9],
  14.        [ 2,  6, 10],
  15.        [ 3,  7, 11],
  16.        [ 4,  8, 12]])

例3：三维的情况

  1. >>> a=[[1,2,3],
  2. ...    [4,5,6]]
  3. >>> b=[[1,2,3],
  4. ...    [4,5,6]]
  5. >>> c=[[1,2,3],
  6. ...    [4,5,6]]
  7. >>> a
  8. [[1, 2, 3], [4, 5, 6]]
  9. >>> b
  10. [[1, 2, 3], [4, 5, 6]]
  11. >>> c
  12. [[1, 2, 3], [4, 5, 6]]
  13. >>> d=np.stack((a,b,c),axis=0)
  14. >>> d
  15. array([[[1, 2, 3],
  16.         [4, 5, 6]],
  18.        [[1, 2, 3],
  19.         [4, 5, 6]],
  21.        [[1, 2, 3],
  22.         [4, 5, 6]]])
  23. >>> d=np.stack((a,b,c),axis=1)
  24. >>> d
  25. array([[[1, 2, 3],
  26.         [1, 2, 3],
  27.         [1, 2, 3]],
  29.        [[4, 5, 6],
  30.         [4, 5, 6],
  31.         [4, 5, 6]]])
  32. >>> d=np.stack((a,b,c),axis=2)
  33. >>> d
  34. array([[[1, 1, 1],
  35.         [2, 2, 2],
  36.         [3, 3, 3]],
  38.        [[4, 4, 4],
  39.         [5, 5, 5],
  40.         [6, 6, 6]]])

3. np.hstack()函数

函数原型：hstack(tup) ，参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。
它其实就是水平(按列顺序)把数组给堆叠起来，vstack()函数正好和它相反。

  1. >>> a=[1,2,3]
  2. >>> b=[4,5,6]
  3. >>> np.hstack((a,b))
  4. array([1, 2, 3, 4, 5, 6])
  7. >>> a=[[1],[2],[3]]
  8. >>> b=[[1],[2],[3]]
  9. >>> c=[[1],[2],[3]]
  10. >>> d=[[1],[2],[3]]
  11. >>> np.hstack((a,b,c,d))
  12. array([[1, 1, 1, 1],
  13.        [2, 2, 2, 2],
  14.        [3, 3, 3, 3]])
  17. >>> a=np.array([1,2,3])
  18. >>> a.shape
  19. (3,)   #3行一列

注意，a=[[1],[2],[3]]是三行一列的，所以横着堆叠就是1堆到一起了

一般情况下：

[1,2]的shape值(2,)，意思是一维数组，数组中有2个元素。
[[1],[2]]的shape值是(2,1)，意思是一个二维数组，每行有1个元素。
[[1,2]]的shape值是（1，2），意思是一个二维数组，每行有2个元素。

4. np.vstack()函数

函数原型：vstack(tup) ，参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。
它是垂直（按照行顺序）的把数组给堆叠起来。

  1. >>> a=[1,2,3]
  2. >>> b=[4,5,6]
  3. >>> np.vstack((a,b))
  4. array([[1, 2, 3],
  5.        [4, 5, 6]])
  8. >>> a=[[1],[2],[3]]
  9. >>> b=[[1],[2],[3]]
  10. >>> c=[[1],[2],[3]]
  11. >>> d=[[1],[2],[3]]
  12. >>> np.vstack((a,b,c,d))
  13. array([[1],
  14.        [2],
  15.        [3],
  16.        [1],
  17.        [2],
  18.        [3],
  19.        [1],
  20.        [2],
  21.        [3],
  22.        [1],
  23.        [2],
  24.        [3]])


————————————————
版权声明：本文为CSDN博主「不务正业的土豆」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yyl424525/article/details/100104177