NumPy(七)： 统计函数&排序、条件函数

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 函数说明如下：

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
>>> print (a)
[[3 7 5]
 [8 4 3]
 [2 4 9]]
>>> print(np.amin(a,1))
[3 3 2]
>>> print(np.amin(a,0))
[2 4 3]
>>> print (np.amax(a))
9
>>> print (np.amax(a, axis =  0))
[8 7 9]
>>> print (np.amax(a, 0))
[8 7 9]

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
>>> print (a)
[[3 7 5]
 [8 4 3]
 [2 4 9]]
>>> print(np.ptp(a))  
7
>>> print(np.ptp(a,0))  
[6 3 6]
>>> print(np.ptp(a,1))  
[4 5 7]

 

numpy.percentile()百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。

numpy.percentile(a, q, axis)

参数说明：

• a: 输入数组
• q: 要计算的百分位数，在 0 ~ 100 之间
• axis: 沿着它计算百分位数的轴

百分数：第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。

举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高

>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> print (a)
[[10  7  4]
 [ 3  2  1]]
# 50% 的分位数，就是 a 里排序之后的中位数
>>> print (np.percentile(a, 50)) 
3.5
>>> print (np.percentile(a, 50, axis=0)) 
[6.5 4.5 2.5]
>>> print (np.percentile(a, 50, axis=1)) 
[7. 2.]
>>> print (np.percentile(a, 50, axis=1, keepdims=True))
[[7.]
 [2.]]

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）--平均值

>>> a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
>>> print (np.median(a))
65.0
>>> print (np.median(a, axis =  0))
[50. 90. 60.]
>>> print (np.median(a, axis =  1))
[65. 80. 60.]

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

>>> a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
>>> print (np.mean(a))
3.6666666666666665
>>> print (np.mean(a, axis =  0))
[2.66666667 3.66666667 4.66666667]
>>> print (np.mean(a, axis =  1))
[2. 4. 5.]

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

>>> a = np.array([1,2,3,4])  
>>> print (a)
[1 2 3 4]
# 不指定权重时相当于 mean 函数
>>> print (np.average(a))
2.5

#设定权重
>>> wts = np.array([4,3,2,1])  
>>> print (np.average(a,weights = wts))
2.0
>>> print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))
(2.0, 10.0)
>>> 

在多维数组中，可以指定用于计算的轴。

标准差

标准差是一组数据平均值分散程度的一种度量。

标准差是方差的算术平方根。

标准差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。

>>> print (np.std([1,2,3,4]))
1.118033988749895

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。

换句话说，标准差是方差的平方根。

>>> print (np.var([1,2,3,4]))
1.25

NumPy 排序、条件刷选函数

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

种类	速度	最坏情况	工作空间	稳定性
'quicksort'（快速排序）	1	O(n^2)	0	否
'mergesort'（归并排序）	2	O(n*log(n))	~n/2	是
'heapsort'（堆排序）	3	O(n*log(n))	0	否

numpy.sort() 函数返回输入数组的排序副本。函数格式如下：

numpy.sort(a, axis, kind, order)

参数说明：

• a: 要排序的数组
• axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
• kind: 默认为'quicksort'（快速排序）
• order: 如果数组包含字段，则是要排序的字段

>>> a = np.array([[3,7],[9,1]])  
>>> print (a)
[[3 7]
 [9 1]]
>>> print (np.sort(a))
[[3 7]
 [1 9]]
>>> print (np.sort(a, axis =  0))
[[3 1]
 [9 7]]

# 在 sort 函数中排序字段 
>>> dt = np.dtype([('name',  'S10'),('age',  int)]) 
>>> a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
>>> print (a)
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
>>> print (np.sort(a, order =  'name'))
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
>>> print (np.sort(a, order =  'age'))  
[(b'ravi', 17) (b'raju', 21) (b'anil', 25) (b'amar', 27)]

numpy.argsort() 函数返回的是数组值从小到大的索引值。

>>> x = np.array([3,  1,  2])  
>>> print (x)
[3 1 2]
>>> y = np.argsort(x)  
>>> y
array([1, 2, 0], dtype=int32)
>>> print (x[y])
[1 2 3]
>>> for i in y:  
    print (x[i], end=" ")

1 2 3 

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

>>> nm =  ('raju','anil','ravi','amar') 
>>> dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
>>> import numpy as np
>>> ind = np.lexsort((dv,nm))
>>> print (ind) 
[3 1 0 2]
>>> print ([nm[i]  +  ", "  + dv[i]  for i in ind])
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

上面传入 np.lexsort 的是一个tuple，排序时首先排 nm，顺序为：amar、anil、raju、ravi 。综上排序结果为 [3 1 0 2]。

msort、sort_complex、partition、argpartition

函数	描述
msort(a)	数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a)	对复数按照先实部后虚部的顺序进行排序。
partition(a, kth[, axis, kind, order])	指定一个数，对数组进行分区
argpartition(a, kth[, axis, kind, order])	可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

>>> import numpy as np
>>> np.sort_complex([5, 3, 6, 2, 1])
array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
>>> a = np.array([3, 4, 2, 1])
 # 将数组 a 中所有元素（包括重复元素）从小到大排列，3 表示的是排序数组索引为 3 的数字，比该数字小的排在该数字前面，比该数字大的排在该数字的后面
>>> np.partition(a, 3)
array([2, 1, 3, 4])
# 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间
>>> np.partition(a, (1, 3))
array([1, 2, 3, 4])

#找到数组的第 3 小（index=2）的值和第 2 大（index=-2）的值
>>> arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])
>>> arr[np.argpartition(arr, 2)[2]]
10
>>> arr[np.argpartition(arr, -2)[-2]]
57

#同时找到第 3 和第 4 小的值。注意这里，用 [2,3] 同时将第 3 和第 4 小的排序好，然后可以分别通过下标 [2] 和 [3] 取得。
>>> arr[np.argpartition(arr, [2,3])[2]]
10
>>> arr[np.argpartition(arr, [2,3])[3]]
23

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

>>> a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
>>> a
array([[30, 40, 70],
       [80, 20, 10],
       [50, 90, 60]])
>>> print(np.argmax(a))
7
>>> print (a.flatten()) 
[30 40 70 80 20 10 50 90 60]
>>> maxindex = np.argmax(a, axis =  0)  
>>> print (maxindex) 
[1 2 0]
>>> maxindex = np.argmax(a, axis =  1)  
>>> print (maxindex) 
[2 0 1]
>>> minindex = np.argmin(a)  
>>> print (minindex) 
5
>>> print (a.flatten()[minindex]) 
10
>>> minindex = np.argmin(a, axis =  0)  
>>> print (minindex) 
[0 1 1]
>>> minindex = np.argmin(a, axis =  1)  
>>> print (minindex)
[0 2 0]

numpy.nonzero() 函数返回输入数组中非零元素的索引。

>>> a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
>>> print (a)
[[30 40  0]
 [ 0 20 10]
 [50  0 60]]
>>> print (np.nonzero (a))
(array([0, 0, 1, 1, 2, 2], dtype=int32), array([0, 1, 1, 2, 0, 2], dtype=int32))

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

>>> x = np.arange(9.).reshape(3,  3)  
>>> print(x)
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
>>> y = np.where(x >  3)  
>>> print(y)
(array([1, 1, 2, 2, 2], dtype=int32), array([1, 2, 0, 1, 2], dtype=int32))
>>> print (x[y])
[4. 5. 6. 7. 8.]

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

>>> x = np.arange(9.).reshape(3,  3)  
>>> print (x)
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
>>> condition = np.mod(x,2)  ==  0  
>>> print (condition)
[[ True False  True]
 [False  True False]
 [ True False  True]]
>>> print (np.extract(condition, x))
[0. 2. 4. 6. 8.]