相关文章
文章目录
tile(平铺)
tile(A,resp)
通过重复resp结构次数来构造数组A。就如tile单词的意思一样，可以想象A是一块砖，以resp样式来就行铺设。
In [1]: import numpy as np
In [2]: a = np.array([1,2,3])
# 如果为数字，则在A基础上上重复
In [3]: np.tile(a,2)
Out[3]: array([1, 2, 3, 1, 2, 3])
# 元组（2，1）表示构建一个（2，1）的数组，并以A填充，下同
In [4]: np.tile(a,(2,1))
Out[4]:
array([[1, 2, 3],
[1, 2, 3]])
In [5]: np.tile(a,(2,2))
Out[5]:
array([[1, 2, 3, 1, 2, 3],
[1, 2, 3, 1, 2, 3]])
In [6]: np.tile(a,(1,2))
Out[6]: array([[1, 2, 3, 1, 2, 3]])
In [7]: np.tile(a,(3,2,1))
Out[7]:
array([[[1, 2, 3],
[1, 2, 3]],
[[1, 2, 3],
[1, 2, 3]],
[[1, 2, 3],
[1, 2, 3]]])
当resp小于原本A的维度时，则会在保留A原有维度。
In [10]: b=np.arange(6).reshape([3,2,1])
In [11]: np.tile(b,(2,1))
Out[11]:
array([[[0],
[1],
[0],
[1]],
[[2],
[3],
[2],
[3]],
[[4],
[5],
[4],
[5]]])
Masked Arrays
什么是Masked Arrays？
数组在有的时候可能会存在无效的或者缺失值。当在这些数组上做一些操作时，我们希望去以我们希望的数值去填充掩盖这些无效的数据。
函数结构
函数结构如下：
x = MaskedArray( data, mask=nomask, dtype=None, copy=False, subok=True, ndmin=0, fill_value=None, keep_mask=True, hard_mask=None, shrink=True, order=None)
| 常用参数 | 说明 |
|---|---|
| data | 数组类型的输入数据 |
| mask | 数组形状的布尔类型的掩码 |
| dtype | 输出数组元素的数据类型 |
| copy | 是否复制输入数组的数据（默认False 为引用） |
| fill_value | 必要时用于填充掩码值的值。如果为None，则使用基于数据类型的默认值。 |
| keep_mask | 将“ mask”与输入数据的掩码（如果有的话）组合（真），将“ mask”用于输出（假）。默认值为True。 |
| hard_msak | 是否使用强mask（不能取消mask），默认（False）不使用。 |
创建MaskedArray
我们可以通过np.ma.masked_array或np.ma.MaskedArray创建带有掩码的MaskedArray数组。
In [1]: import numpy as np
In [3]: a = np.array([1,2,3,4,np.nan,6,7,np.nan,9])
In [4]: mask_a = np.ma.masked_array(a,np.isnan(a))
In [5]: mask_a
Out[5]:
masked_array(
data=[1.0, 2.0, 3.0, 4.0, --, 6.0, 7.0, --, 9.0],
mask=[False, False, False, False, True, False, False, True, False],
fill_value=1e+20)
copy
copy，是否复制输入数组的数据（默认False 为引用）
# 默认是False，为引用
# 可以看到当mask_a修改时，a的值也同时修改了
In [3]: a
Out[3]: array([0, 1, 2, 3, 4])
In [4]: mask_a = np.ma.masked_array(a, a < 2)
In [5]: mask_a[0] = 5
In [6]: mask_a
Out[6]:
masked_array(
data=[5, --, 2, 3, 4],
mask=[False, True, False, False, False],
fill_value=999999)
In [7]: a
Out[7]: array([5, 1, 2, 3, 4])
# 现在我们将设为True，为a的副本
# 可以看到当mask_a修改时，a的值没有修改
In [8]: mask_a = np.ma.masked_array(a, a < 2,copy = True)
In [9]: mask_a[0] = 4
In [10]: mask_a
Out[10]:
masked_array(
data=[4, --, 2, 3, 4],
mask=[False, True, False, False, False],
fill_value=999999)
In [11]: a
Out[11]: array([5, 1, 2, 3, 4])
fill_value
设置默认填充值。填充值不会参与计算
In [14]: a = np.arange(5)
In [15]: mask_a = np.ma.masked_array(a, a< 2, fill_value= 2)
In [16]: mask_a
Out[16]:
masked_array(
data=[--, --, 2, 3, 4],
mask=[ True, True, False, False, False],
fill_value=2)
In [17]: mask_a.mean()
Out[17]: 3.0
In [18]: mask_a.filled()
Out[18]: array([2, 2, 2, 3, 4])
clip
clip(a, a_min, a_max, out=None, **kwargs)
裁剪（限制）数组中的值。
使用clip函数可以控制值的范围，将其限制在最大最小区间内，对于小于最小值和大于最大值的项以设置的最大最小值替代。
In [12]: a = np.arange(10)
In [13]: a
Out[13]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [14]: a.clip(3,7)
Out[14]: array([3, 3, 3, 3, 4, 5, 6, 7, 7, 7])
In [15]: np.clip(a,3,7)
Out[15]: array([3, 3, 3, 3, 4, 5, 6, 7, 7, 7])
In [16]: a
Out[16]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [17]: np.clip(a,3,7,out=a)
Out[17]: array([3, 3, 3, 3, 4, 5, 6, 7, 7, 7])
也可以使用多个不同的最大最小值结合限制数组
In [27]: a
Out[27]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [28]: a.clip([2,0,3,3,3,3,3,3,4,0],7)
Out[28]: array([2, 1, 3, 3, 4, 5, 6, 7, 7, 7])
合并
| 方法 | 含义 |
|---|---|
| append | 将值附加到数组的末尾。 |
| concatenate、ma.concatenate | 沿现有轴连接一系列数组。保存输入的mask。 |
| stack | 沿新轴堆叠一系列数组。 |
| block | 从块组合数组。 |
| hstack | 沿水平折叠（沿第二维） |
| vstack | 垂直顺序排列阵列（沿第一维） |
| dstack | 按深度顺序排列数组（沿第三维） |
In [1]: import numpy as np
append
np.append(arr,values,axis=None)
append是将值添加到数组arr副本的末尾，如果指定arr，其中values是和arr相同形状的。如果未指定axis则会默认展平为一维数组。值得注意的是append不会就地发生,而是分配并填充了一个新数组。 因此，在速度上并不是很快。
默认情况下：
In [2]: a = np.arange(12).reshape(2,3,2)
In [3]: b = np.arange(3)
In [4]: np.append(a,b)
Out[4]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 0, 1, 2])
有轴axis的情况下：
我们可以看到如果制定了轴，上面的a、b合并时会报错。这是因为除了指定的轴外，b上的其它轴必须一致才可以。
In [7]: np.append(a,b,axis = 1)
ValueError: all the input arrays must have same number of dimensions
# a的shape是(2,3,2)、所以如果在axis = 1上合并，
# 则b的shape必须是(2,x,2)的样式。
In [8]: b = np.arange(4).reshape(2,1,2)
In [9]: np.append(a,b,axis = 1)
Out[9]:
array([[[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 0, 1]],
[[ 6, 7],
[ 8, 9],
[10, 11],
[ 2, 3]]])
# 例如下面定义a(1,2),则如果想在axis = 0插入，
# 则b邀为(x,2)的数组才可以
In [13]: a = np.arange(2).reshape(1,2)
In [14]: b = np.arange(4).reshape(2,2)
In [15]: np.append(a,b,axis = 0)
Out[15]:
array([[0, 1],
[0, 1],
[2, 3]])
concatenate
concatenate((a1, a2, ...), axis=0, out=None)
其中，a1、a2等要级联的数组必须是有相同形状的，默认是假设这些数组是三维的，所以如果在轴axis=0上进行级联，那么a1、a2等数组的形状必须是(x, _, _)。其中只能x位置可以为不相同的正整数外，其他位置必须一致。
# 默认的是axis = 0
In [13]: a = np.arange(2).reshape(1,2)
In [14]: b = np.arange(4).reshape(2,2)
In [18]: np.concatenate((a,b))
Out[18]:
array([[0, 1],
[0, 1],
[2, 3]])
# 如果想在axis = 1上级联，则是不可以的因为除了
# axis = 1外，形状并不相同。
In [19]: np.concatenate((a,b),axis = 1)
ValueError: all the input array dimensions except for
the concatenation axis must match exactly
# 因此我们将a转置一下就好了。
In [20]: np.concatenate((a.T,b), axis = 1)
Out[20]:
array([[0, 0, 1],
[1, 2, 3]])
当axis为None时，合并所有数组元素。
In [21]: np.concatenate((a.T,b),axis = None)
Out[21]: array([0, 1, 0, 1, 2, 3])
值得注意的是，如果你传入的是MaskedArrays数组，那么使用np.concatenate是不会保存mask的。你需要使用np.ma.concatenate。
In [23]: mask_a
Out[23]:
masked_array(
data=[0, 1, 2, 3, --],
mask=[False, False, False, False, True],
fill_value=2)
In [24]: mask_b
Out[24]:
masked_array(
data=[--, 6, 7, 8, 9],
mask=[True, False, False, False, False],
fill_value=5)
# 使用np.concatenate无法保存mask
In [25]: np.concatenate((mask_a,mask_b))
Out[25]:
masked_array(
data=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
mask=False,
fill_value=999999)
# 使用np.ma.concatenate可以保存mask 但依旧保存不了填充值
In [26]: np.ma.concatenate((mask_a,mask_b))
Out[26]:
masked_array(
data=[0, 1, 2, 3, --, --, 6, 7, 8, 9],
mask=[False, False, False, False, True, True, False, False, False, False],
fill_value=999999)
stack
np.stack(arrays, axis=0, out=None)
沿新轴连接一系列数组。这里的每个数组必须要有相同的形状(沿轴)。axis指定了新轴的位置。例如，a和b的形状都是(3,)。那么a和b堆叠后的结果就只能为沿axis=0得到形状(2,3)或者沿axis=1得到形状(3,2)这两种情况。
In [8]: a = np.arange(3)
In [9]: b = np.arange(3,6)
In [11]: np.stack((a,b),axis = 0)
Out[11]:
array([[0, 1, 2],
[3, 4, 5]])
In [12]: np.stack((a,b),axis = 1)
Out[12]:
array([[0, 3],
[1, 4],
[2, 5]])
再举一个例子，如果a和b是一个形状为(4,3)的数组，那么堆叠起来就有axis=0，axis=1，axis=2分别对应形状(2,4,3)，(4,2,3)，(4,3,2)这三种。
In [13]: a = np.arange(12).reshape(4,3)
In [14]: b = np.arange(1,13).reshape(4,3)
In [15]: np.stack([a,b],axis = 0).shape
Out[15]: (2, 4, 3)
In [16]: np.stack([a,b],axis = 1).shape
Out[16]: (4, 2, 3)
In [17]: np.stack([a,b],axis = 2).shape
Out[17]: (4, 3, 2)
block
np.block(arrays)
函数block就是将数组按块排版。就像下图所示的这样，对于矩阵
[
M
]
\begin{bmatrix}M\end{bmatrix}
[M]，我们可以通过四小块构成：
[
A
B
C
D
]
\begin{bmatrix} A&B\\ C&D \end{bmatrix}
[ACBD]。
In [4]: a = np.arange(4).reshape(2,2)
In [5]: b = np.arange(6).reshape(2,3)
In [6]: c = np.arange(2).reshape(2,1)S
In [7]: d = np.arange(8).reshape(2,4)
In [8]: np.block([[a,b],[c,d]])
Out[8]:
array([[0, 1, 0, 1, 2],
[2, 3, 3, 4, 5],
[0, 0, 1, 2, 3],
[1, 4, 5, 6, 7]])
hstack、vstack、dstack
hstack
np.hstack(tup)
hstack方法等价于concatenate方法沿着axis=1级联（1-D数组沿axis=0）。
- 1-D
通俗理解，hstack的意思是horizontal stack即水平堆叠。假设对于两个形状分别为(3,)和(2,)的1-D数组，因此我们只需要在水平轴上拼接即可。得到一个形状为(5,)的数组。
In [3]: a = np.arange(3)
In [4]: b = np.arange(2)
In [5]: np.hstack((a,b))
Out[5]: array([0, 1, 2, 0, 1])
- 2-D及以上
现在，让我们在1-D的基础上再加一维，假设对于两个形状分别为(2,3)和(4,5)的2-D数组进行水平堆叠是没有办法堆叠出一个规则数组的。我们令a，b分别是形状为(2,2)，(2,3)的数组，这样a在水平上的两形状为(2,)的元素就可以和b上的两个(3,)分别进行水平堆叠。
In [33]: a = np.arange(4).reshape(2,2)
In [34]: b = np.arange(6).reshape(2,3)
In [35]: np.hstack((a,b))
Out[35]:
array([[0, 1, 0, 1, 2],
[2, 3, 3, 4, 5]])
如果在2-D以上叠加时，其实和2-D并无区别。我们可以把更高维度抽象为一个元素，只要这个元素的形状相同就能够使得其在水平上堆叠。总的来说在更高维度上水平堆叠时，仅需保持除axis=1轴外形状相同即可。
In [5]: b = np.arange(24).reshape(2,3,4)
In [6]: a = np.arange(16).reshape(2,2,4)
In [7]: np.hstack((a,b))
Out[7]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
vstack
np.vstack(tup)
vstack方法等价于concatenate方法沿着axis=0级联。
- 1-D
通俗理解，vstack的意思是vertically stack即垂直堆叠。假设对于两个形状分别为(3,)和(2,)的1-D数组，我们想要垂直堆叠是做不到的。
因此只有形状相同的情况下，两个数组才能垂直堆叠在一起。就像下图中的a，b在np.vasack((a,b))后就得到下右图所示现状为(2,3)的数组。
In [9]: a = np.arange(3)
In [10]: b = np.arange(3)
In [11]: np.vstack((a,b))
Out[11]:
array([[0, 1, 2],
[0, 1, 2]])
- 2-D及以上
在垂直堆叠时，可对比hstack水平堆叠。我们可以将更高维度就行抽象，除axis=0外，只要高层保持形状相同便可以进行堆叠。
# 对于二维
In [4]: a = np.arange(6).reshape(2,3)
In [5]: b = np.arange(9).reshape(3,3)
In [6]: np.vstack((a,b))
Out[6]:
array([[0, 1, 2],
[3, 4, 5],
[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
# 对于三维
In [7]: b = np.arange(9).reshape(3,3,1)
In [8]: a = np.arange(6).reshape(2,3,1)
In [9]: np.vstack((a,b))
Out[9]:
array([[[0],
[1],
[2]],
[[3],
[4],
[5]],
[[0],
[1],
[2]],
[[3],
[4],
[5]],
[[6],
[7],
[8]]])
dstack
np.dstack(tup)
dstack就是depth stack，是沿着axis=2进行堆叠的。
对于1-D形状为(M,)的数组，会被重塑为(1,M,1)的形状，来进行深度堆叠，对于2-D形状为(M.N)的数组则会被重塑为(M,N,1)的形状，来进行深度堆叠。
# 对于一维
In [14]: a = np.arange(3)
In [15]: b = np.arange(3)
In [16]: np.dstack((a,b))
Out[16]:
array([[[0, 0],
[1, 1],
[2, 2]]])
# 对于二维
In [18]: b = np.arange(6).reshape(2,3)
In [19]: a = np.arange(6).reshape(2,3)
In [20]: np.dstack((a,b))
Out[20]:
array([[[0, 0],
[1, 1],
[2, 2]],
[[3, 3],
[4, 4],
[5, 5]]])
总结
这三个函数对三维的阵列是最有意义的。例如，对于具有高度（第一轴），宽度（第二轴）和深度（第三轴）的数据。我们只需要记住vstack、hstack、dstack是分别对第一、二、三轴进行操作。
读者如果处理多维数据，建议使用函数concatenate，stack和block提供的更常规的堆叠和串联操作。
拆分
| 方法 | 含义 |
|---|---|
| split | 将一个数组拆分为多个子数组。 |
| array_split | 将一个数组拆分为大小相等或近似相等的多个子数组。 |
| hsplit | 水平（按列）将数组拆分为多个子数组。 |
| vsplit | 垂直（逐行）将数组拆分为多个子数组。 |
| dsplit | 沿第3轴（深度）将数组拆分为多个子数组。 |
split
np.split(ary, indices_or_sections, axis=0)
如果indices_or_sections是整型N，则数组arr会被切分成N整份。如果不够切分则报错。
In [5]: a = np.arange(8)
# 切割成两份，够切
In [6]: np.split(a,2)
Out[6]: [array([0, 1, 2, 3]), array([4, 5, 6, 7])]
# 切割成三份，不够切 报错
In [7]: np.split(a,3)
ValueError: array split does not result in an equal division
如果indices_or_sections是1-D数组，则会根据数组段来进行切分，举个例子；如果indices_or_sections的值为[2,5]，则会将arr分为arr[:2]、arr[2:5]、arr[5:]三个部分。当超出数组索引范围时，则会以空数组替代。
In [9]: a = np.arange(10)
# 未超出数组索引范围
In [10]: np.split(a,[2,5])
Out[10]: [array([0, 1]), array([2, 3, 4]), array([5, 6, 7, 8, 9])]
# 超出数组索引范围
In [13]: np.split(a,[2,5,10])
Out[13]:
[array([0, 1]),
array([2, 3, 4]),
array([5, 6, 7, 8, 9]),
array([], dtype=int32)]
array_split
np.array_split(ary, indices_or_sections, axis=0)
与split不同的是，array_split的indices_or_sections参数只能为整型，且不够切分时N等份时，最后一块则以len(arr)%N保留，它的并无差别。
# 一维
In [4]: a = np.arange(8)
In [5]: np.array_split(a,3)
Out[5]: [array([0, 1, 2]), array([3, 4, 5]), array([6, 7])]
#二维
In [8]: b = np.arange(8).reshape(2,4)
In [9]: np.array_split(b,2,axis = 1)
Out[9]:
[array([[0, 1],
[4, 5]]),
array([[2, 3],
[6, 7]])]
hsplit、vsplit、dsplit
- hsplit
np.hsplit(ary, indices_or_sections)
hsplit是沿着axis=1进行切分。indices_or_sections详细切分使用过程与split相似。
In [24]: a = np.arange(12).reshape(2,6)
# 够切，则切
In [25]: np.hsplit(a,3)
Out[25]:
[array([[0, 1],
[6, 7]]), array([[2, 3],
[8, 9]]), array([[ 4, 5],
[10, 11]])]
# 不够，则报错
In [26]: np.hsplit(a,4)
ValueError: array split does not result in an equal division
# 按数组切分
In [28]: np.hsplit(a,[3,5])
Out[28]:
[array([[0, 1, 2],
[6, 7, 8]]),
array([[ 3, 4],
[ 9, 10]]),
array([[ 5],
[11]])]
- vsplit
与hsplit类似，这里不过多赘述。
In [29]: a = np.arange(12).reshape(2,6)
# 够切，则切
In [30]: np.vsplit(a,2)
Out[30]: [array([[0, 1, 2, 3, 4, 5]]), array([[ 6, 7, 8, 9, 10, 11]])]
# 不够，则报错
In [31]: np.vsplit(a,3)
ValueError: array split does not result in an equal division
# 按数组切分
In [32]: np.vsplit(a,[0,1])
Out[32]:
[array([], shape=(0, 6), dtype=int32),
array([[0, 1, 2, 3, 4, 5]]),
array([[ 6, 7, 8, 9, 10, 11]])]
- dsplit
与hsplit类似，这里不过多赘述。
In [37]: a = np.arange(20).reshape(2,2,6)
# 够切，则切
In [38]: np.dsplit(a,2)
Out[38]:
[array([[[ 0, 1, 2],
[ 6, 7, 8]],
[[12, 13, 14],
[18, 19, 20]]]),
array([[[ 3, 4, 5],
[ 9, 10, 11]],
[[15, 16, 17],
[21, 22, 23]]])]
# 不够，则报错
In [39]: np.dsplit(a,4)
ValueError: array split does not result in an equal division
# 按数组切分
In [40]: np.dsplit(a,[1,2])
Out[40]:
[array([[[ 0],
[ 6]],
[[12],
[18]]]),
array([[[ 1],
[ 7]],
[[13],
[19]]]),
array([[[ 2, 3, 4, 5],
[ 8, 9, 10, 11]],
[[14, 15, 16, 17],
[20, 21, 22, 23]]])]
eye和identity(单位阵)
eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
返回一个二维数组，对角线上是1，其它地方为0。当k为正上移对象线，k为负时下移对角线。
In [3]: np.eye(2)
Out[3]:
array([[1., 0.],
[0., 1.]])
In [4]: np.eye(4,k=1)
Out[4]:
array([[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.],
[0., 0., 0., 0.]])
In [5]: np.eye(4,k=-1)
Out[5]:
array([[0., 0., 0., 0.],
[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.]])
identity(n, dtype=None)
与eye不同的是identity仅能创建对角矩阵。
In [10]: np.identity(3)
Out[10]:
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
set_printoptions(设置输出）
set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None)
设置浮点数的精确度。
In [2]: np.set_printoptions(precision= 5)
In [3]: np.array([1.254831,0.235482])
Out[3]: array([1.25483, 0.23548])
折叠数组，默认值为1000，当数组中的元素超过1000时就会被折叠。下面设置treshold=7，即超过7项的数组会被折叠。当设置比6小的数时并不一定会折叠，这是因为折叠至少需要6个数
In [24]: np.set_printoptions(threshold= 7)
In [25]: np.arange(7)
Out[25]: array([0, 1, 2, 3, 4, 5, 6])
In [26]: np.arange(8)
Out[26]: array([0, 1, 2, ..., 5, 6, 7])
# 当设置的折叠数过小时
In [30]: np.set_printoptions(threshold= 5)
In [31]: np.arange(6)
Out[31]: array([0, 1, 2, 3, 4, 5])
254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
