list,tuple和numpy中nparray及np.hstack()，np.vstack()，np.stack()函数关系及用法解析

增补stack的理解：The stacked array has one more dimension than the input arrays.注意：arrays的含义！！！！
numpy.stack(arrays, axis=0, out=None)
arrays：sequence of array_like即arrays总要比输出arrays低一维，arrays里面的每一个array里面的每个元素(可能是个列表，元组，或者是个numpy的数组，函数会自动转化为数组来做最终的堆叠)堆叠成最终的一个array
1.对于组合(stack)不同的list或tuple：stack()函数会先把参数中的每个元素变成numpy的数组形式，如：
stack(arrays, axis=0, out=None)[source]不同于hstack(tup)[source]¶，前者一定会增加一维！即前者的参数arrays和tuple中的元素是要被堆叠的对象！而后者hstack和vstack不一定有维度的增加！主要用来增加某一轴的长度！
例如：

数组形式：arrays的每一个元素为二维的3*4矩阵数组，处理后应为三维数组
>>> arrays = [np.random.randn(3, 4) for _ in range(10)]##生成的arrays的元素才是要堆叠的对象！！！
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)#输出表明即新增加的维在第0轴
>>> np.stack(arrays, axis=1).shape ##要被堆叠的元素为10个，所以新增加的轴长长度为10，即表示要在arrays的要被堆叠元素（3*4矩阵）中的第1维 变为轴长为10！
(3, 10, 4)即输出表明新增加的维在第1轴

**上式等价于**：当转化为数组后，数组内的元素才是即要被堆叠的对象，即为二维矩阵
>>> arrays= [
                3*4的矩阵list，
                3*4的矩阵list，
                ...，
                3*4的矩阵列表，
              ]###生成的3行四列的array为列表
>>> np.stack(arrays, axis=0).shape
(10,3,4)  ##要被堆叠的元素为10个，所以新增加的轴长长度为10，stack参数arrays最外层的[]相当于hstack和vstack中常用的（），如vstack((a,b))中a,b的外层括号，都是不算入输入的维度，arrays中元素和a、b才算输入的维度，前者输出的array会相当于arrays中元素增加一个轴，而后者只是轴长扩展

**上式还等价于：**
array1=3*4列表
array2=3*4列表
...
array10=3*4列表
>>> np.stack(（array1，array2，...，array10）, axis=0).shape##要被堆叠的元素为10个，所以新增加的轴长长度为10！！
(10,3,4)  ##stack参数最外层的（）相当于stack中常用的arrays的最外层的[].

对于arrays是list或tuple的情况，如下例元素为一维时，输出为两维（注意处理是会先转化为数组），如下：

a=[[1,2,3],
   [4,5,6]]#a为list
c=np.stack(a,axis=0) #要堆叠的元素为2个，所以新增加的轴长长度为2，[1,2,3]和[4,5,6]是元素，axis=0即在要堆叠的元素的最外层加括号，所以最终为2*3矩阵数组
即print c为：
[[1 2 3]
 [4 5 6]]
再如：
c=np.stack(a,axis=1)
print(c)
即print c为：
[[1 4]
 [2 5]
 [3 6]]#要堆叠的元素为2个，所以新增加的轴长长度为2，即[1,2,3]和[4,5,6]是元素。为一维向量，需要变为二维矩阵，因为要堆叠的元素是一维向量，所以axis=1即在元素的最内层加括号，加完后再合并，合并的过程按照第1轴向合并，axis=1所以最终为3*2矩阵数组

注意 ：：：：：：对于hstack和vstack的使用：

如
import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.vstack((a,b)))
输出：
[[1 2 3]
 [4 5 6]]#即a和b即为1维数组，也可以看为1*3的二维数组，本质是一样的，所以vstack会增加第0轴的长度由1到2

再如：
import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.hstack((a,b)))

输出：[1 2 3 4 5 6 ]#即a和b即为1维数组，也可以看为1*3的二维数组，本质是一样的，所以hstack会增加第1轴的长度由3到6，而第0轴轴长不变

2.对于组合(stack)不同的数组（主要针对np.vstack和hstack对数组的处理）：即ndarray类的对象，即用np.array()函数构造的ndarray类的对象（实例），其中，hstack和vstack不一定有维度的增加！主要用来增加某一轴的长度！如vstack((a,b))输出的数组维度同a或b。

---

对于arrays的元素为一维时，输出为两维，如下：

a=np.array（[[1,2,3],
   [4,5,6]]）#a为arrays
c=np.stack(a,axis=0) #要堆叠的元素为2个，所以新增加的轴长长度为2，[1,2,3]和[4,5,6]是要被堆叠的元素，axis=0即在元素的最外层加括号
即print c为：
[[1 2 3]
 [4 5 6]]
再如：
c=np.stack(a,axis=1)
print(c)
即print c为：
[[1 4]
 [2 5]
 [3 6]]#要堆叠的元素为2个，所以新增加的轴长长度为2，即[1,2,3]和[4,5,6]是元素。为一维向量，需要变为二维矩阵，axis=1即在元素的最内层加括号，加完后再合并，合并的过程按照第1轴向合并

>>>
>>> a = np.floor(10*np.random.np.random((2,2)))
>>> a
array([[ 1.,  1.],
       [ 5.,  8.]])

>>> b = np.floor(10*np.random.np.random((2,2)))
>>> b
array([[ 3.,  3.],
       [ 6.,  0.]])

>>> np.vstack((a,b))
array([[ 1.,  1.],
       [ 5.,  8.],
       [ 3.,  3.],
       [ 6.,  0.]])
注意结果中第0轴长度增加了（记忆时，可把最外层中括号当做第0轴，然后展平成一排，找里面的逗号分隔的每一个【】项是第0轴对应的元素！按竖直方向即第0轴堆叠后，第0轴的长度+2！
>>> np.hstack((a,b))
array([[ 1.,  1.,  3.,  3.],
       [ 5.,  8.,  6.,  0.]]) 
注意结果中第1轴长度增加了，而第0轴的轴长未变，即当秩为2或者说维度为2时或者说数组有2个轴时，是变化的第1轴的长度

另外，函数column_stack以列将一维数组合成二维数组，它等同与vstack对一维数组。如下：

>>> np.column_stack((a,b))   # With 2D arrays
array([[ 1.,  1.,  3.,  3.],
       [ 5.,  8.,  6.,  0.]])
>>> a=np.array([4.,2.])
>>> b=np.array([2.,8.])
>>> a[:,newaxis]  # This allows to have a 2D columns vector
array([[ 4.],
       [ 2.]])
>>> np.column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4.,  2.],
       [ 2.,  8.]])
>>> np.vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different
array([[ 4.],
       [ 2.],
       [ 2.],
       [ 8.]]) 

注：对那些维度比二维更高的数组，hstack沿着第1轴，vstack沿着第0轴进行堆叠,concatenate允许可选参数给出组合时沿着的轴。

---

基础：
NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是同种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。例如，在3D空间一个点的坐标[1, 2, 3]是一个秩为1的数组，因为它只有一个轴。那个轴长度为3.又例如，在以下例子中，数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.

[[ 1., 0., 0.],
 [ 0., 1., 2.]] 

NumPy的数组类被称作ndarray。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组和提供少量功能。更多关于numpy的重要ndarray对象属性有：

ndarray.ndim：数组轴的个数，在python的世界中，轴的个数被称作秩
ndarray.shape：数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性
ndarray.size：数组元素的总个数，等于shape属性中元组元素的乘积。
ndarray.dtype：一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。
ndarray.itemsize：数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).
ndarray.data：包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素。

在python中存在列表，元组，字典，集合等数据结构，其中列表和元组常作为numpy库中函数及其他自定义函数的参数，另外，在编程中，列表、元组与numpy中数组之间的转换用的比较多，下面以hstack()，vstack()，stack()函数等为例介绍处理列表、数组作为参数的用法：

1.首先，我们应建立一个概念，list不管是几层嵌套，打印出来都是一维的（似乎没有数组中维度的概念），例如：

直接的：
a=[[1,2,3],
   [4,5,6]]
print("列表a如下：")
输出结果：
[[1, 2, 3], [4, 5, 6]] #有逗号，打印，表明是列表的打印，而不是数值数组
再例如：
import numpy as np
a=[[1,2,3,4],
   [5,6,7,8],
   [9,10,11,12]]
b=np.array([[1,2,3,4],
   [5,6,7,8],
   [9,10,11,12]])
 即a为列表，b为数组

2.另外，由列表list转换到数值数组类型必须是list中各元素格式相同，如下：

如上例中的列表a中的两个元素[1,2,3]和[4,5,6]的形状是一样的，如下的list是不可以用np.array（）转换为数组的
a=[[1,2,3],
   [4,5]]

3.常识：对于nparray数组来说，是有维度区分的，假设有三个维度，即对应第一个维度为第0轴，第二个维度为第1轴，第三个维度为第2轴。在脑海里排列这些数组，总要让最后一维的元素横向排列，其他维的元素纵向排列，这样有利于理解numpy库的函数处理及print打印输出的形式！
例如：

a=np.array([[[1, 4],
             [2, 5],
             [3, 6]],
            [[1, 4],
             [2, 5],
             [3, 6]],
            [[1, 4],
             [2, 5],
             [3, 6]]]
)
输出：
[[[1 4]
  [2 5]
  [3 6]]

 [[1 4]
  [2 5]
  [3 6]]

 [[1 4]
  [2 5]
  [3 6]]]
以上第一个类似RGB图像的通道层，第一个维度的每个元素是一张图像，是两个维度的矩阵，在脑海里可以想象一下，其中最后一个维度，即图像矩阵的行向分别为
1 4
2 5
3 6

1 4
2 5
3 6

1 4
2 5
3 6

4.numpy的hstack()函数用法
如np.hstack(value),要求输入参数value作为参数必须具有相同的数据结构，可以是元组也可以是列表（或者是numpy的数组，在此不做数组的举例），但不管是什么，在该函数处理中都会value整体转化为tuple处理，并把value中基本的元素转为数组进行处理，且hstack的h的意思是不管是value是多少嵌套的list或tuple，都是指按照axis=最后一个轴向或者说维度进行value的堆叠，例如：

一般用法：
a=(1, 2, 3)
b=(4, 5, 6)
print(np.hstack((a, b))) #hstack会将value中具有相同结构的a，b的数值组合以最后一维即横向的方式组合在一起，并以同value同样的数据结构返回numpy数组
输出：
[1, 2, 3, 4, 5, 6]
再例如以列表为参数，其中参数中的元素为一维数组：
>>> np.hstack([np.array([1, 2, 3]), np.array([4, 5, 6])])
array([1, 2, 3, 4, 5, 6])
与np.hstack(value)类似的函数,column表示Stack 1-D arrays as columns into a 2-D array.（即list转化为元组，将元组中的一维向量以列的形式横向排列成二维数组）
>>> np.column_stack([np.array([1, 2, 3]), np.array([4, 5, 6])])
array([[1, 4],
       [2, 5],
       [3, 6]])
但np.column_stack的tuple参数中元素只能是1-D或2D的数组！！！
例如：
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
       [2, 3],
       [3, 4]])

5.numpy的vstack()函数用法同numpy.vstack()函数用法。
numpy.vstack(tup)即Stack arrays in sequence vertically (row wise)，代表第0轴方向即竖直方向上堆叠参数tuple的元素（元素会转化为数组），row wise代表元素中嵌套的元素以行形式排列。

例如：
>>> np.vstack([np.array([1, 2, 3]), np.array([4, 5, 6])])
array([[1, 2, 3],
       [4, 5, 6]])
与np.vstack(value)类似的函数,row表示Stack 1-D arrays as raw into a 2-D array.（即list转化为元组，将元组中的一维向量以行的形式纵向排列成二维数组）
>>> np.row_stack([np.array([1, 2, 3]), np.array([4, 5, 6])])
array([[1, 2, 3],
       [4, 5, 6]])

再例如：

Equivalent to np.concatenate(tup, axis=0) if tup contains arrays that are at least 2-dimensional.

6.numpy的stack()函数
stakck（value）
函数原型：numpy.stack(arrays, axis=0)

程序实例：

>>> arrays = [np.random.randn(3, 4) for _ in range(10)]  
>>> np.stack(arrays, axis=0).shape  
(10, 3, 4)  

>>>  

>>> np.stack(arrays, axis=1).shape  
(3, 10, 4)  

>>>  

>>> np.stack(arrays, axis=2).shape  
(3, 4, 10)  

>>>  

>>> 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]])  

7.numpy.concatenate((a1, a2, …), axis=0)
即默认以纵向

Examples

>>>
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])
This function will not preserve masking of MaskedArray inputs.

>>>
>>> a = np.ma.arange(3)
>>> a[1] = np.ma.masked
>>> b = np.arange(2, 5)
>>> a
masked_array(data = [0 -- 2],
             mask = [False  True False],
       fill_value = 999999)
>>> b
array([2, 3, 4])
>>> np.concatenate([a, b])
masked_array(data = [0 1 2 2 3 4],
             mask = False,
       fill_value = 999999)
>>> np.ma.concatenate([a, b])
masked_array(data = [0 -- 2 2 3 4],
             mask = [False  True False False False False],
       fill_value = 999999)