Python数据分析——Numpy
0.杂项记录
range()与numpy.arange()对比
-
range(start,end,step)
-
range(start,end,step),返回一个range.object(迭代值),起始值为start，终止值为end，但不含终止值，步长为step。只能创建int型list。 -
如果省略
step参数,则默认为1。如果省略start参数，则默认为0 -
如过
step是正数,最后一个元素是小于step的最大元素；如果step是负数，最后一个元素是大于stop的最小元素,step不能为0。 -
for i in range(1,5): print(i) 1 2 3 4
-
-
np.arange(start,end,step)
-
np.arange(start,end,step),与range()类似,也不含终止值,但是返回一个array对象。需要导入numpy模块，并且arange可以使用float数据 -
参数： start：数字，可选 间隔开始。间隔包括这个值。默认的起始值是0。 stop：数字 间隔结束。间隔不包括此值，但在某些情况下，步骤不是整数，浮点舍入会影响out的长度。 dtype：步长，可选 值之间的间隔。对于任何输出出来，这是两个相邻值之间的距离，进行[I + 1] - 出[I] 。默认步长为1.如果指定了step，则还必须给出start。 dtype：dtype 输出数组的类型。如果没有给出dtype，则从其他输入参数推断数据类型。 返回： 类型：ndarray 数组间距均匀的值。 对于浮点参数，结果的长度是 ceil（（stop - start）/ step）向上取整。由于浮点溢出，此规则可能导致out的最后一个元素大于stop。 -
# 实例 >>> np.arange(3) array([0, 1, 2]) >>> np.arange(3.0) array([ 0., 1., 2.]) >>> np.arange(3,7) array([3, 4, 5, 6]) >>> np.arange(3,7,2) array([3, 5])
-
1.多维数组
数组的纬度 ndim
-
通过
ndarray.ndim可以查看数组的纬度 -
a = np.array([1,2,3,]) print(a.ndim) # 1 b = np.array([[1,2,3],[4,5,6]]) print(b.ndim) # 2 c = np.array([ [ [1,2,3], [4,5,6] ], [ [7,8,9], [10,11,12] ] ]) print(c.ndim) # 3
数组的形状(几行几列)及纬度 shape
-
通过
ndarray.shape可以查看数组的形状 -
a = np.array([1,2,3]) print(a.shape) # 输出 (3,) 说明：这里输出的元组(3,)按官方的文档理解，这里的3表示的是第一个维度中元素的大小（size）; b = np.array([[1,2,3],[3,4,5]]) print(b.shape) # 输出(2,3) 元组(2,3) 说明这是一个二维数组，其中第一个维度含有2个元素，第二个维度中每一个元素都含有3个元素(1,2,3). -
总结
通过以上的例子，我们可以知道对于numpy中数组的shape属性输出的元组，有以下两个结论：- 元组的元素的个数等于维度数
- 元组中每一个元素又代表中每一维度元素的个数（从左到右，依次为第一维度中元素的个数，第二维度中元素的个数…第n维度元素的个数）
改变行列 reshape
-
numpy.arange(n).reshape(a,b)依次生成 n n n个自然数，并且以 a a a行 b b b列的数组形式显示-
np.arange(16).reshape(2,8) #生成16个自然数，以2行8列的形式显示 arr = np.arange(16).reshape(2,8) print(arr) 结果： [ [ 0 1 2 3 4 5 6 7] [ 8 9 10 11 12 13 14 15] ]
-
-
mat(or array).reshape(c, -1)必须是矩阵格式或者数组格式，才能使用.reshape(c, -1)函数,表示将此矩阵或者数组重组,以 c c c行的形式表示-
arr = np.arange(16).reshape(2,8) arr = arr.reshape(4,-1) # 将arr变为4行的格式,其中列数自动计算 列数 = 16/4 = 4 #自动计算 print(arr) 结果: [ [ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15] ]
-
-
mat(or array).reshape(-1, c)必须是矩阵格式或者数组格式，才能使用.reshape(-1, c)函数,表示将此矩阵或者数组重组,以 c c c列的形式表示-
arr = np.arange(16).reshape(2,8) arr = arr.reshape(-1,2) # 将arr变为2列的格式,其中行数自动计算 行数 = 16/2 = 8 #自动计算 print(arr) 结果: [ [ 0 1] [ 2 3] [ 4 5] [ 6 7] [ 8 9] [10 11] [12 13] [14 15] ]
-
查看元素大小 itemszie
-
ndarray.itemsize输出ndarray对象中每个元素的大小,以字节为单位-
a=np.array([1,2,3,4]) print(a.itemsize) # 4 b=np.array([1.,2.,3.,4.]) print(b.itemsize) #8 float64 c=np.array([1,2,3,4],dtype=float) print(c.itemsize) #8
-
2.数组的索引与切片
一维数组
- 索引:
arr[i]表示取数组的第 i i i个数 - 切片:
arr[i:j]表示取数组的第 [ i ∼ j − 1 ] [i \sim j-1] [i∼j−1]个元素(左闭右开) - 切片赋值:
arr[i:j]=x表示将数组的第 [ i ∼ j − 1 ] [i \sim j-1] [i∼j−1]个元素赋值为 x x x
二维数组
arr[x,y]:取第 i i i行第 j j j列的数arr[x]:取第 x x x行的数arr[:,x]:取第 x x x列的数
花式索引
- 花式索引指的是利用整数数组进行索引.
arr[1,3,5,6,7]:取数组的第1、3、5、6、7行(以二维数为例)arr[[1,2],[3,4]]:取数组的第1行第3列,第2行第4列arr[1:3,3:5]:取数组的第1行第3列,第1行第4列,第2行第3列,第2行第4列
布尔索引
-
我们可以通过一个布尔数组来索引目标数组，以此找出与布尔数组中值为True的对应的目标数组中的数据，提取的条件可以有多个,用
&表示且,|表示或,多个条件时每个条件用圆括号包裹。 -
布尔型数组的长度和索引的数组的行数（轴长度）必须一致。
-
arr3 = (np.arange(36)).reshape(6,6)#生成6*6的数组 arr3 Out[35]: array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29], [30, 31, 32, 33, 34, 35]]) x = np.array([0, 1, 2, 1, 4, 5]) x == 1#通过比较运算得到一个布尔数组 Out[42]: array([False, True, False, True, False, False], dtype=bool) arr3[x == 1] #布尔索引 Out[43]: array([[ 6, 7, 8, 9, 10, 11], [18, 19, 20, 21, 22, 23]]) # 从结果上看，布尔索引取出了布尔值为True的行。 -
利用布尔索引将小于15的数全部置为0
-
arr[arr<=15]=0
-
值的替换
- 利用索引替换
a1 = np.arange(0,24).reshape(4,6)
a1[3] = 0 #将第三行的所有值替换成0
print(a1)
#结果:
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[ 0 0 0 0 0 0]]
- 利用条件索引
a1 = np.arange(0,24).reshape(4,6)
a1[a1<5] = 0 #将小于5的所有值替换成0
print(a1)
#结果:
[[ 0 0 0 0 0 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
- 利用
np.where()函数实现
a1 = np.arange(0,24).reshape(4,6)
a1 = np.where(a1<10,1,0) #把a1中所有小于10的数变为1,其余变为0
print(a1)
#结果:
[[1 1 1 1 1 1]
[1 1 1 1 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]]
3.数组的广播机制
广播的原则：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。
4.数组形状的操作
4.1reshape和resize
reshape是将数组转换为指定的形状,然后返回转换后的结果,对于原数组的形状是不会发生改变的.resize是将数组转换为指定的形状,会直接修改数组本身。并不会返回任何值
4.2flatten和ravel
-
flatten是将数组转换为一维数组后,然后将这个拷贝返回回去,所以后续对这个返回值进行修改不会影响之前的数组. -
ravel是将数组转换为一维数组后,将这个视图(可以理解为引用)返回回去,所以后序对这个返回值进行修改会影响之前的数组x = np.arrat([1,2],[3,4]) x.flatten()[0]=100 #x[0][0]仍为1 x.ravel()[0]=100 #x[0][0]变为100
4.3不同数组的组合
如果有多个数组想要组合在一起,也可以通过其中的一些函数来实现
1.vstack:将数组按垂直方向进行叠加,数组的列数必须相同才能叠加
a1 = np.random.randint(0,10,size=(3,5))
a2 = np.random.randint(0,10,size=(1,5))
a3 = np.vstack([a1,a2]) # 参数中谁在前表示这个数组叠加在前面
a1:
[[1 7 9 1 0]
[0 9 2 9 2]
[9 5 8 8 7]]
a2:
[[5 7 4 8 0]]
a3:
[[1 7 9 1 0]
[0 9 2 9 2]
[9 5 8 8 7]
[5 7 4 8 0]]
2.hstack:将数组按水平方向进行叠加,数组的行数必须相同才能叠加
a1 = np.random.randint(0,10,size=(3,2))
a2 = np.random.randint(0,10,size=(3,1))
a3 = np.hstack([a1,a2]) # 参数中谁在前表示这个数组叠加在前面
a1:
[[8 0]
[1 7]
[2 2]]
a2:
[[0]
[6]
[3]]
a3:
[[8 0 0]
[1 7 6]
[2 2 3]]
3.concatenate((a,b),axis):将两个数组叠加,根据参数决定是水平方向还是垂直方向
- axis = 1: 代表往水平方向(列)上叠加
- axis = 0: 代表往垂直方向(行)上叠加
- axis = None: 会将两个数组合成一个一维数组
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]])
np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])
4.4数组的切割
- 通过
hsplit和vsplit以及array_split可以将一个数组进行切割。
-
hsplit:按照列进行切割。用于指定分割成几列,可以使用数字来代表分成几部分,也可以使用数组来代表分隔的地方,返回类型为list。a = np.arange(16).reshape(4,4) array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]) np.hsplit(a,2) #水平分割成两部分,需能被列数整除 [array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]]) ] np.hsplit(a,[1,3]) #按照列索引进行分割,以第1列,第3列进行分割 -->>分为三部分 1.第0列 2.第1-2列 3.第3列 [array([[ 0], [ 4], [ 8], [12]]), array([[ 1, 2], [ 5, 6], [ 9, 10], [13, 14]]), array([[ 3], [ 7], [11], [15]]) ] -
vsplit:按照行进行切割。用于指定分割成几行,可以使用数字来代表分成几部分,也可以使用数组来代表分隔的地方,返回类型为list。 -
array_split:可以指定参数axis，axis=0表示按行进行切割,axis=1表示按列进行切割,不指定参数则默认参数为0.同时其可以奖数组切割为几部分,不要求可以整除a = np.arange(16).reshape(4,4) array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]) np.array_split(a,2) #不指定参数,默认参数为0按行切割 [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])] np.array_split(a,2,0) #参数为0按行切割 [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])] np.array_split(a,2,1) #参数为1按列切割 [array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]])] np.array_split(a,3) #不均等切割 [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
4.5数组(矩阵)的转置
- 使用
.T或者transpose()进行转置,返回的是一个View(修改View会对原数组造成影响)
c = np.arange(15).reshape(3,5)
print(c)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
d = c.T #或者c.transpose()
print(d)
[[ 0 5 10]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]
d[0] = 100
print(c)
[[100 1 2 3 4]
[100 6 7 8 9]
[100 11 12 13 14]]
print(d)
[[100 100 100]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]
4.6拷贝
#1.直接赋值
a = np.arange(10)
b = a #这种情况不会进行拷贝
print(b is a) #返回True,说明a和b是相同的
b[0] = 100
print(a[0]) # ----> 100 a会被修改
#2.View或者浅拷贝
a = np.arange(10)
c = a.view()
print(c is a) #返回False,说明c和a是两个不同的变量
c[0] = 100
print(a[0]) # ----> 100 a会被修改
#3.深拷贝
a = np.arange(10)
c = a.copy() #numpy里的copy
#列表字典等的copy方法：浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
print(c is a) #返回False,说明c和a是两个不同的变量
c[0] = 100
print(a[0]) # ----> 0 a不会被修改
5.NAN值和INF值的处理
5.1对NAN值和INF值的认识
-
NAN:Not A number,不是一个数字的意思,其本身属于浮点类型 -
INF:Infinity,代表的是无穷大的意思,也是属于浮点类型。np.inf表示正无穷大，-np.inf表示负无穷大,一般在出现除数为0的时候为无穷大。比如2/0 -
NAN和NAN不相等,比如np.NAN != np.NAN这个条件是成立的 -
NAN和任何值做运算,结果都是NAN。 -
data = np.random.randint(0,10,size=(3,5)) data = data.astype(float) data[0,1] = np.NAN #将某个值变为NAN data/0 array([[inf, nan, inf, nan, inf], # 0/0为nan [inf, nan, inf, inf, inf], [inf, inf, inf, inf, inf]])
5.2删除缺失值
# 1.删除所有NAN的值,因为删除了值后数组不知道该怎么变化,所以会变成一维数组
data = np.random.randint(0,10,size=(3,5)).astype(np.float)
data[0,1] = np.nan
data = data[~np.isnan(data)] # 此时的data会没有nan,并且会变成一个1维数组
# 2.删除NAN所在的行
data = np.random.randint(0,10,size=(3,5)).astype(np.float) #转化为浮点类型,便于测试实验
data[[0,1],[1,2]] = np.NAN #将第(0,1)和(1,2)两个值设为NAN
lines = np.where(np.isnan(data))[0] #为什么后面有个0呢?因为where在这返回了一个元组,第0个元素是值为NAN的元素所在行数下标组成的数组
#使用delete方法删除指定的行,axis=0表示删除行,lines表示删除的行号
data1 = np.delete(data,lines,axis=0)
6.random模块
np.random为我们提供了许多获取随机数的函数。
6.1 np.random.seed()
用于指定随机数生成时所用算法开始的整数值,如果使用相同的seed()值,则每次生成的随机数都相同,如果不设置这个值,则系统根据时间来自己选择这个值.
np.random.seed(1)
print(np.random.rand()) #打印a
print(np.random.rand()) #不一定与上次相同,因为随机数种子只对下一次随机数的产生有影响
6.2 np.random.rand()
生成一个值为[0,1]之间的数组,形状由参数指定,如果没有参数,那么将返回一共随机值
data1 = np.random.rand(2,3,4) #生成2块3行4列的数组,值从0-1之间产生
data2 = np.random.rand() #生成一个0-1之间的随机数
6.3 np.random.rann()
生成均值( μ μ μ)为0,标准差( σ \sigma σ)为1的标准正态分布的值。
data = np.random.randn(2,3) #生成一个2行3列的数组,数组中的值都满足标准正态分布
6.4 np.random.randint()
生成指定范围内的随机整数,并可以通过size参数指定纬度。
data1 = np.random.randint(10,size=(3,5)) #生成值在0-9之间,3行5列的数组
data2 = np.random.randint(1,20,size=(3,6)) #生成值在1-19之间,3行6列的数组
6.5 np.random.choice()
从一个列表或者数组中,随机进行采样。或者是从指定的区间中进行采样,采样个数可以通过参数指定。
data = [1,10,3,2,3,10]
result1 = np.random.choice(data,size=(2,3)) #从data中随机采样,生成2行3列的数组
result2 = np.random.choice(data,3) #从data中随机采样,生成3个数据的一维数组
result3 = np.random.choice(10,3) #从0-9之间随机取3个值生成一个一维数组
6.6 np.random.shuffle()
把原来数组的元素的位置打乱
a = np.arange(10)
np.random.shuffle(a) #将a的元素的位置进行打乱,没有返回值
7.axis轴的理解
- 通常理解为axis = 0代表列,axis = 1代表行
简单来说， 最外面的括号代表着 axis=0，依次往里的括号对应的 axis 的计数就依次加 1。什么意思呢？下面再来解释一下。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PLvPpwKI-1631711154586)(…/…/新建文件夹/picture/axis1-16317097750821.png)]
最外面的括号就是axis=0，里面两个子括号axis=1。
操作方式：如果指定轴进行相关的操作，那么他会使用轴下的每个直接子元素的第0个，第1个，第2个…分别进行相关的操作。
现在我们用刚刚理解的方式来做几个操作。比如现在有一个二维的数组：
x = np.array([[0,1],[2,3]])
-
求
x数组在axis=0和axis=1两种情况下的和：>>> x.sum(axis=0) array([2, 4])为什么得到的是[2,4]呢，原因是我们按照
axis=0的方式进行相加，那么就会把最外面轴下的所有直接子元素中的第0个位置进行相加，第1个位置进行相加…依此类推，得到的就是0+2以及2+3，然后进行相加，得到的结果就是[2,4]。>>> x.sum(axis=1) array([1, 5])因为我们按照
axis=1的方式进行相加，那么就会把轴为1里面的元素拿出来进行求和，得到的就是0,1，进行相加为1，以及2,3进行相加为5，所以最终结果就是[1,5]了。 -
用
np.max求axis=0和axis=1两种情况下的最大值：
>>> np.random.seed(100)
>>> x = np.random.randint(0,10,size=(3,5))
>>> x.max(axis=0)
array([8, 8, 3, 7, 8])
因为我们是按照axis=0进行求最大值，那么就会在最外面轴里面找直接子元素，然后将每个子元素的第0个值放在一起求最大值，将第1个值放在一起求最大值，以此类推。而如果axis=1，那么就是拿到每个直接子元素，然后求每个子元素中的最大值：
>>> x.max(axis=1)
array([8, 5, 8])
-
用
np.delete在axis=0和axis=1两种情况下删除元素：>>> np.delete(x,0,axis=0) array([[2, 3]])np.delete是个例外。我们按照axis=0的方式进行删除，那么他会首先找到最外面的括号下的直接子元素中的第0个，然后删掉，剩下最后一行的数据。>>> np.delete(x,0,axis=1) array([[1], [3]])同理，如果我们按照
axis=1进行删除，那么会把第一列的数据删掉。
三维以上数组：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OyQtRyO2-1631711154589)(…/…/新建文件夹/picture/axis2.png)]
按照之前的理论，如果以上数组按照axis=0的方式进行相加，得到的结果如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OhGkk8UU-1631711154590)(…/…/新建文件夹/picture/axis3.png)]
如果是按照axis=1的方式进行相加，得到的结果如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wq1VWHD5-1631711154592)(…/…/新建文件夹/picture/axis4.png)]
8.通用函数
8.1 一元函数：
| 函数 | 描述 |
|---|---|
| np.abs | 绝对值 |
| np.sqrt | 开根 |
| np.square | 平方 |
| np.exp | 计算指数(e^x) |
| np.log，np.log10，np.log2，np.log1p | 求以e为底，以10为低，以2为低，以(1+x)为底的对数 |
| np.sign | 将数组中的值标签化，大于0的变成1，等于0的变成0，小于0的变成-1 |
| np.ceil | 朝着无穷大的方向取整(向上取整)，比如5.1会变成6，-6.3会变成-6 |
| np.floor | 朝着负无穷大方向取证(向下取整)，比如5.1会变成5，-6.3会变成-7 |
| np.rint，np.round | 返回四舍五入后的值 |
| np.modf | 将整数和小数分隔开来形成两个数组 |
| np.isnan | 判断是否是nan |
| np.isinf | 判断是否是inf |
| np.cos，np.cosh，np.sin，np.sinh，np.tan，np.tanh | 三角函数 |
| np.arccos，np.arcsin，np.arctan | 反三角函数 |
8.2 二元函数：
| 函数 | 描述 |
|---|---|
| np.add | 加法运算（即1+1=2），相当于+ |
| np.subtract | 减法运算（即3-2=1），相当于- |
| np.negative | 负数运算（即-2），相当于加个负号 |
| np.multiply | 乘法运算（即2*3=6），相当于* |
| np.divide | 除法运算（即3/2=1.5），相当于/ |
| np.floor_divide | 取整运算，相当于// |
| np.mod | 取余运算，相当于% |
| greater,greater_equal,less,less_equal,equal,not_equal | >,>=,<,<=,=,!=的函数表达式 |
| logical_and | &的函数表达式 |
| logical_or | |的函数表达式 |
8.3 聚合函数：
| 函数名称 | NAN安全版本 | 描述 |
|---|---|---|
| np.sum | np.nansum | 计算元素的和 |
| np.prod | np.nanprod | 计算元素的积 |
| np.mean | np.nanmean | 计算元素的平均值 |
| np.std | np.nanstd | 计算元素的标准差 |
| np.var | np.nanvar | 计算元素的方差 |
| np.min | np.nanmin | 计算元素的最小值 |
| np.max | np.nanmax | 计算元素的最大值 |
| np.argmin | np.nanargmin | 找出最小值的索引 |
| np.argmax | np.nanargmax | 找出最大值的索引 |
| np.median | np.nanmedian | 计算元素的中位数 |
使用np.sum或者是a.sum即可实现。并且在使用的时候，可以指定具体哪个轴。同样Python中也内置了sum函数，但是Python内置的sum函数执行效率没有np.sum那么高，可以通过以下代码测试了解到：
a = np.random.rand(1000000)
%timeit sum(a) #使用Python内置的sum函数求总和，看下所花费的时间
%timeit np.sum(a) #使用Numpy的sum函数求和，看下所花费的时间
8.4 布尔数组的函数：
| 函数名称 | 描述 |
|---|---|
| np.any | 验证任何一个元素是否为真 |
| np.all | 验证所有元素是否为真 |
比如想看下数组中是不是所有元素都为0，那么可以通过以下代码来实现：
np.all(a==0)
# 或者是
(a==0).all()
比如我们想要看数组中是否有等于0的数，那么可以通过以下代码来实现：
np.any(a==0)
# 或者是
(a==0).any()
8.5 排序：
-
np.sort：指定轴进行排序。默认是使用数组的最后一个轴进行排序。a = np.random.randint(0,10,size=(3,5)) b = np.sort(a) #按照行进行排序，因为最后一个轴是1，那么就是将最里面的元素进行排序。 c = np.sort(a,axis=0) #按照列进行排序，因为指定了axis=0还有
ndarray.sort()，这个方法会直接影响到原来的数组，而不是返回一个新的排序后的数组。 -
np.argsort：返回排序后的下标值。示例代码如下：np.argsort(a) #默认也是使用最后的一个轴来进行排序。 -
降序排序：
np.sort默认会采用升序排序。如果我们想采用降序排序。那么可以采用以下方案来实现：# 1. 使用负号 -np.sort(-a) # 2. 使用sort和argsort以及take indexes = np.argsort(-a) #排序后的结果就是降序的 np.take(a,indexes) #从a中根据下标提取相应的元素
8.6 其他函数补充：
-
np.apply_along_axis：沿着某个轴执行指定的函数。示例代码如下：# 求数组a按行求均值，并且要去掉最大值和最小值。 np.apply_along_axis(lambda x:x[(x != x.max()) & (x != x.min())].mean(),axis=1,arr=a) -
np.linspace：用来将指定区间内的值平均分成多少份。示例代码如下：# 将0-1分成12分，生成一个数组 np.linspace(0,1,12) -
np.unique：返回数组中的唯一值。# 返回数组a中的唯一值，并且会返回每个唯一值出现的次数。 np.unique(a,return_counts=True)
8.7 更多
[https://docs.scipy.org/doc/numpy/reference/index.html](
扫一扫
670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
