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() 函数返回输入数组的排序副本。函数格式如下：

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

参数说明：

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

import numpy as np

a = np.array([[3, 7], [9, 1]])
print('我们的数组是：')
print(a)
print('\n')

print('调用 sort() 函数：')
print(np.sort(a))
print('\n')

print('按列排序：')
print(np.sort(a, axis=0))
print('\n')

print('按行列排序：')
print(np.sort(a, axis=1))
print('\n')

输出结果：

我们的数组是：
[[3 7]
[9 1]]

调用 sort() 函数：
[[3 7]
[1 9]]

按列排序：
[[3 1]
[9 7]]

按行列排序：
[[3 7]
[1 9]]

 

在 sort 函数中，指定排序字段

import numpy as np

dt = np.dtype([('name', 'S10'), ('age', int)])
a = np.array([("aaa", 21), ("ccc", 25), ("ddd", 17), ("bbb", 27)], dtype=dt)
print('a数组：',a)
print('按 name 排序：',np.sort(a, order='name'))

输出结果为：

a数组： [(b'aaa', 21) (b'ccc', 25) (b'ddd', 17) (b'bbb', 27)]
按 name 排序： [(b'aaa', 21) (b'bbb', 27) (b'ccc', 25) (b'ddd', 17)]

numpy.argsort()

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

import numpy as np 
 
x = np.array([3,  1,  2])  
print ('我们的数组是：')
print (x)
print ('\n')

print ('对 x 调用 argsort() 函数：')
y = np.argsort(x)  
print (y)
print ('\n')

print ('以排序后的顺序重构原数组：')
print (x[y])
print ('\n')

print ('使用循环重构原数组：')
for i in y:  
    print (x[i], end=" ")

输出结果为：

我们的数组是：
[3 1 2]

对 x 调用 argsort() 函数：
[1 2 0]

以排序后的顺序重构原数组：
[1 2 3]

使用循环重构原数组
1 2 3

numpy.lexsort()

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

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

import numpy as np 
 
nm =  ('raju','anil','ravi','amar') 
dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
ind = np.lexsort((dv,nm))  

print ('调用 lexsort() 函数：') 
print (ind) 
print ('\n') 

print ('使用这个索引来获取排序后的数据：') 
print ([nm[i]  +  ", "  + dv[i]  for i in ind])

输出结果为：

调用 lexsort() 函数：
[3 1 0 2]

使用这个索引来获取排序后的数据：
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

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

 

import numpy as np

# 录入了四位同学的成绩，按照总分排序，总分相同时语文高的优先
math    = (10, 20, 50, 10)
chinese = (30, 50, 40, 60)
total   = (40, 70, 90, 70)

# 将优先级高的项放在后面
ind = np.lexsort((math, chinese, total))

for i in ind:
    print(total[i],chinese[i],math[i])

输出，是按总成绩排序，相同时语文成绩优先级更高:

40 30 10
70 50 20
70 60 10
90 40 50

 

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 指定算法沿着指定轴对数组进行分区

 

sort_complex 复数排序

import numpy as np

print(np.sort_complex([5, 3, 6, 2, 1]))
print(np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]))

输出结果：

[1.+0.j 2.+0.j 3.+0.j 5.+0.j 6.+0.j]
[1.+2.j 2.-1.j 3.-3.j 3.-2.j 3.+5.j]

partition 分区排序

import numpy as np

a = np.array([3, 4, 2, 1])

# 将数组 a 中所有元素（包括重复元素）从小到大排列，3 表示的是排序数组索引为 3 的数字，比该数字小的排在该数字前面，比该数字大的排在该数字的后面
print(np.partition(a, 3))

# 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间
print(np.partition(a, (1, 3)))

输出结果：

[2 1 3 4]
[1 2 3 4]

argpartition

找到数组的第 3 小（index=2）的值和第 2 大（index=-2）的值

import numpy as np

arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])

print(arr[np.argpartition(arr, 2)[2]])
print(arr[np.argpartition(arr, -2)[-2]])

输出结果：
10
57

同时找到第 3 和第 4 小的值。注意这里，用 [2,3] 同时将第 3 和第 4 小的排序好，然后可以分别通过下标 [2] 和 [3] 取得。

import numpy as np

arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])
print(arr[np.argpartition(arr, [2,3])[2]])
print(arr[np.argpartition(arr, [2,3])[3]])

输出结果：

10
23

二、条件筛选函数

numpy.argmax() 和 numpy.argmin()

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

import numpy as np

a = np.array([[30, 40, 70], [80, 20, 10], [50, 90, 60]])
print('我们的数组是：')
print(a)
print('\n')

maxindex = np.argmax(a)
print('调用 argmax() 函数：',maxindex)
minindex = np.argmin(a)
print('调用 argmin() 函数：',minindex)

print('展开数组：',a.flatten())
print('展开数组中的最小值：',a.flatten()[minindex])
print('展开数组中的最大值：',a.flatten()[maxindex])

maxindex = np.argmax(a, axis=0)
print('沿轴 0 的最大值索引：',maxindex)
minindex = np.argmin(a, axis=0)
print('沿轴 0 的最小值索引：',minindex)

maxindex = np.argmax(a, axis=1)
print('沿轴 1 的最大值索引：',maxindex)
minindex = np.argmin(a, axis=1)
print('沿轴 1 的最小值索引：',minindex)

输出结果为：

我们的数组是：
[[30 40 70]
[80 20 10]
[50 90 60]]

调用 argmax() 函数： 7
调用 argmin() 函数： 5
展开数组： [30 40 70 80 20 10 50 90 60]
展开数组中的最小值： 10
展开数组中的最大值： 90
沿轴 0 的最大值索引： [1 2 0]
沿轴 0 的最小值索引： [0 1 1]
沿轴 1 的最大值索引： [2 0 1]
沿轴 1 的最小值索引： [0 2 0]

 

numpy.nonzero()

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

import numpy as np 
 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  

print ('我们的数组是：')
print (a)
print ('\n')

print ('调用 nonzero() 函数：')
print (np.nonzero (a))

输出结果为：

我们的数组是：
[[30 40  0]
 [ 0 20 10]
 [50  0 60]]

调用 nonzero() 函数：
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where()

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

import numpy as np

x = np.arange(9.).reshape(3, 3)
print('我们的数组是：')
print(x)
print('\n')

y = np.where(x > 3)
print('大于 3 的元素的索引：')
print(y)
print('\n')

print('使用这些索引来获取满足条件的元素：')
print(x[y])

输出结果为：

我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

使用这些索引来获取满足条件的元素：
[4. 5. 6. 7. 8.]

numpy.extract()

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

import numpy as np 
 
x = np.arange(9.).reshape(3,  3)  
print ('我们的数组是：')
print (x)

# 定义条件, 选择偶数元素
condition = np.mod(x,2)  ==  0  
print ('按元素的条件值：')
print (condition)

print ('使用条件提取元素：')
print (np.extract(condition, x))

输出结果为：

我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

按元素的条件值：
[[ True False  True]
 [False  True False]
 [ True False  True]]

使用条件提取元素：
[0. 2. 4. 6. 8.]

三、统计函数

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

带轴向就是计算整行或整列的最大值和最小值，不带轴向，就是整个数组的最大值和最小值

numpy.amin() 和 numpy.amax()

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

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

import numpy as np

a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print('我们的数组是：')
print(a)
print('\n')

print('调用 amin() 函数：')
print(np.amin(a, 1))
print('\n')

print('再次调用 amin() 函数：')
print(np.amin(a, 0))
print('\n')

print('调用 amax() 函数：')
print(np.amax(a, 1))
print('\n')

print('再次调用 amax() 函数：')
print(np.amax(a, axis=0))
print('\n')

print('整个数组中最大和最小值为：')
print(np.amin(a),np.amax(a))

输出结果为：

我们的数组是：
[[3 7 5]
[8 4 3]
[2 4 9]]

调用 amin() 函数：
[3 3 2]

再次调用 amin() 函数：
[2 4 3]

调用 amax() 函数：
[7 8 9]

 

再次调用 amax() 函数：
[8 7 9]

整个数组中最大和最小值为：
2 9

numpy.ptp()

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

The name of the function comes from the acronym for 'peak to peak'

 

import numpy as np

a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print('a数组：')
print(a)
print('\n')

print('调用 ptp() 函数：',np.ptp(a))
print('沿轴 1 调用 ptp() 函数：',np.ptp(a, axis=1))
print('沿轴 0 调用 ptp() 函数：',np.ptp(a, axis=0))

输出结果为：

a数组：
[[3 7 5]
[8 4 3]
[2 4 9]]

调用 ptp() 函数： 7
沿轴 1 调用 ptp() 函数： [4 5 7]
沿轴 0 调用 ptp() 函数： [6 3 6]

numpy.percentile()

　　百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 

numpy.percentile(a, q, axis)

参数说明：

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

首先明确百分位数：

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

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

import numpy as np

a = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
p1 = np.percentile(a, 50)
p2 = np.percentile(a, 50, axis=1)
p3 = np.percentile(a, 50, axis=0)

print("a数组:\n",a,"\n")

print("p1:", p1)
print("p2:", p2)
print("p3:", p3)

输出结果：

a数组:
[[10 20 30]
[40 50 60]
[70 80 90]]

 

p1: 50.0
p2: [20. 50. 80.]
p3: [40. 50. 60.]

 

import numpy as np

a = np.array([[10, 7, 4], [3, 2, 1]])
print('a数组是：')
print(a)
print ('\n')


print('调用 percentile() 函数：',np.percentile(a, 50))              # 50% 的分位数，就是 a 里排序之后的中位数
print('纵列调用 percentile() 函数：',np.percentile(a, 50, axis=0)) # axis 为 0，在纵列上求
print('横行调用 percentile() 函数：',np.percentile(a, 50, axis=1)) # axis 为 1，在横行上求
print ('\n')

print('横行调用 percentile() 函数,保持维度不变：')
print(np.percentile(a, 50, axis=1, keepdims=True))                  # 保持维度不变

输出结果为：

a数组是：
[[10 7 4]
[ 3 2 1]]

调用 percentile() 函数： 3.5
纵列调用 percentile() 函数： [6.5 4.5 2.5]
横行调用 percentile() 函数： [7. 2.]

横行调用 percentile() 函数,保持维度不变：
[[7.]
[2.]]

 

numpy.median()

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

import numpy as np 
 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  

print ('我们的数组是：')
print (a)
print ('\n')

print ('调用 median() 函数：')
print (np.median(a))
print ('\n')

print ('沿轴 0 调用 median() 函数：')
print (np.median(a, axis =  0))
print ('\n')

print ('沿轴 1 调用 median() 函数：')
print (np.median(a, axis =  1))

输出结果为：

我们的数组是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]

调用 median() 函数：
65.0

沿轴 0 调用 median() 函数：
[50. 90. 60.]

沿轴 1 调用 median() 函数：
[65. 80. 60.]

numpy.mean()

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

算术平均值是沿轴的元素的总和除以元素的数量。

import numpy as np 
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print ('我们的数组是：')
print (a)
print ('\n')

print ('调用 mean() 函数：')
print (np.mean(a))
print ('\n')

print ('沿轴 0 调用 mean() 函数：')
print (np.mean(a, axis =  0))
print ('\n')

print ('沿轴 1 调用 mean() 函数：')
print (np.mean(a, axis =  1))

输出结果为：

我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

调用 mean() 函数：
3.6666666666666665

沿轴 0 调用 mean() 函数：
[2.66666667 3.66666667 4.66666667]

沿轴 1 调用 mean() 函数：
[2. 4. 5.]

numpy.average()

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

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

 

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

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

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

import numpy as np

a = np.array([1, 2, 3, 4])
print('我们的数组是：')
print(a)
print('\n')

print('不指定权重，调用 average() 函数：',np.average(a))   # 不指定权重时相当于 mean 函数

wts = np.array([4, 3, 2, 1])
print('指定权重后，调用 average() 函数：',np.average(a, weights=wts))


# 如果 returned 参数设为 true，同时返回权重的和
print('returned=True，调用 average() 函数：',)
print(np.average([1, 2, 3, 4], weights=[4, 3, 2, 1], returned=True))    # 权重和：4+3+2+1=10

输出结果为：

我们的数组是：
[1 2 3 4]

不指定权重，调用 average() 函数： 2.5
指定权重后，调用 average() 函数： 2.0
returned=True，调用 average() 函数：
(2.0, 10.0)

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

import numpy as np

a = np.arange(6).reshape(3, 2)
print('我们的数组是：')
print(a)
print('\n')


wt = np.array([3, 5])
print('指定权重后，调用 average() 函数：')
print(np.average(a, axis=1, weights=wt))
print('\n')

print('returned=True，调用 average() 函数：')
print(np.average(a, axis=1, weights=wt, returned=True))     # 返回每一行的权重

输出结果为：

我们的数组是：
[[0 1]
[2 3]
[4 5]]

指定权重后，调用 average() 函数：
[0.625 2.625 4.625]

returned=True，调用 average() 函数：
(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))

标准差

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

标准差=sqrt(((x1-x)^2 +(x2-x)^2 +......(xn-x)^2)/n)

 

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

import numpy as np 
 
print (np.std([1,2,3,4]))

输出结果为：

1.1180339887498949

方差

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

方差=((x1-x)^2 +(x2-x)^2 +......(xn-x)^2)/n

 

import numpy as np
 
print (np.var([1,2,3,4]))

输出结果为：

1.25