增补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 64.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)
扫一扫
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
