Python的axis，stack

二位数组：

（1）使用0值表示沿着每一列或行标签\索引值向下执行方法

（2） 使用1值表示沿着每一行或者列标签模向执行对应的方法

n维：

n 维空间里有 n 个坐标轴，并且坐标轴互相垂直。同一条坐标轴来说，坐标值相同的点在同一个 n-1 维的“平面”上。而所谓的延轴计算实际上是降维的过程，同一个坐标轴上的点合并成一个点，这样n维空间就变成了 n-1 维空间。

比如，延0轴计算就是去掉坐标中的第一个索引。过程就是

1. 遍历其他索引的所有可能组合
2. 取出一个组合，保持值不变，遍历第一个索引所有可能值
3. 根据索引可以获得了同一个轴上的所有元素
4. 对他们进行计算得到最后的元素
5. 所有组合的最后结果组到一起就是最后的 n-1 维数组

沿轴计算过程，可以当做沿哪一个方向进行投影再进行计算。所以如果一个多维数组的 shape 是 (a, b, c, d), 那么延轴0计算最后的数组shape 是 (b, c, d), 延轴1计算最后的数组shape是 (a, c, d)消失的那个坐标轴上的点合并成一个点。

stack函数：轴=0 ：按外层标签取

                  axis=1，按内层标签取

>>> a = np.array([1, 2, 3])  
>>> b = np.array([2, 3, 4])  
>>> np.stack((a, b))  
array([[1, 2, 3],  
       [2, 3, 4]])  
  
>>>  
  
>>> np.stack((a, b), axis=-1)  
array([[1, 2],  
       [2, 3],  
       [3, 4]])  

　　

stack和axis结合（按轴堆叠）

eg：三维为例，axis=0：延最外层的轴，及延下例的a，b，c，d外层元素堆叠 

                        axis=1：延第二层的轴，及下例的【1,2,3】等（一行一行的取）

                        axis=2：延第三层的轴，下例的最内层元素1 等（一行一行的取）

a = 
 [[1 2 3]
 [4 5 6]]
b = 
 [[11 12 13]
 [14 15 16]]
c = 
 [[21 22 23]
 [24 25 26]]
d = 
 [[31 32 33]
 [34 35 36]]

s = np.stack((a, b, c, d), axis=0)
    print('axis = 0 ', s.shape, '\n', s)

axis = 0  (4, 2, 3) 
 [[[ 1  2  3]
  [ 4  5  6]]

 [[11 12 13]
  [14 15 16]]

 [[21 22 23]
  [24 25 26]]

 [[31 32 33]
  [34 35 36]]]

 s = np.stack((a, b, c, d), axis=1)
    print('axis = 1 ', s.shape, '\n', s)

axis = 1  (2, 4, 3) 
 [[[ 1  2  3]
  [11 12 13]
  [21 22 23]
  [31 32 33]]

 [[ 4  5  6]
  [14 15 16]
  [24 25 26]
  [34 35 36]]]

 s = np.stack((a, b, c, d), axis=2)
    print('axis = 2 ', s.shape, '\n', s)

axis = 2  (2, 3, 4) 
 [[[ 1 11 21 31]
  [ 2 12 22 32]
  [ 3 13 23 33]]

 [[ 4 14 24 34]
  [ 5 15 25 35]
  [ 6 16 26 36]]]

　　可参考vstack、hsatck http://blog.csdn.net/csdn15698845876/article/details/73380803