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()
sort()函数返回输入数组的排序副本。 它有以下参数：
numpy.sort(a, axis, kind, order)
其中：
| 序号 | 参数及描述 |
|---|---|
| 1. | a要排序的数组 |
| 2. | axis沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序 |
| 3. | kind默认为'quicksort'（快速排序） |
| 4. | 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( '沿轴 0 排序：')
print( np.sort(a, axis = 0))
print( '\n')
# 在 sort 函数中排序字段
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print( '我们的数组是：')
print( a)
print( '\n')
print( '按 name 排序：')
print( np.sort(a, order = 'name'))
输出如下：
我们的数组是：
[[3 7]
[9 1]]
调用 sort() 函数：
[[3 7]
[1 9]]
沿轴 0 排序：
[[3 1]
[9 7]]
我们的数组是：
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
按 name 排序：
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]
numpy.lenxsort()
默认按最后一行元素有小到大排序,返回最后一行元素排序后索引所在位置
a = [1,5,1,4,3,4,4] # First column
b = [9,4,0,4,0,2,1] # Second column
ind = np.lexsort((b,a)) # Sort by a, then by b
print(ind)
输出如下：
[2 0 4 6 5 3 1]
对上述排序的过程分析如下，np.lexsort完成了这下面几步：
index:012356
a:1514344
先根据a内的数据对每个元素从小到大进行排序可以得到
index_sorted_v1:0243561
但是可以看到0,2的大小同为1，3,5,6大小同为4，一般argsort的话会按照原本的顺序来拍，但这里是lexsort，并且我们有b，所以利用b内对应位置元素的大小来进行排序
b_sorted_v1:9004214
index_sorted_v2:2046531
这就是我们得到的结果ind。
这个排序好比进行数据库查询一样，假如数据库表demo的数据如下：
+------+-------+
| age | salar |
+------+-------+
| 10 | 20 |
| 9 | 26 |
| 29 | 14 |
| 40 | 60 |
| 30 | 70 |
按照salar降序排列，然后按照age进行升序排列
select age,salar from demo order by salar desc,age asc;
+------+-------+
| age | salar |
+------+-------+
| 30 | 70 |
| 40 | 60 |
| 9 | 26 |
| 10 | 20 |
| 29 | 14 |
+------+-------+
官网上对lexsort的示例更加丰富，连接地址：https://docs.scipy.org/doc/numpy/reference/generated/numpy.lexsort.html
示例
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],)
输出如下：
我们的数组是：
[3 1 2]
对 x 调用 argsort() 函数：
[1 2 0]
以排序后的顺序重构原数组：
[1 2 3]
使用循环重构原数组：
1 2 3
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],)
输出如下：
我们的数组是：
[3 1 2]
对 x 调用 argsort() 函数：
[1 2 0]
以排序后的顺序重构原数组：
[1 2 3]
使用循环重构原数组：
1 2 3
NumPy模块有一些用于在数组内搜索的函数。提供了用于找到最大值，最小值以及满足给定条件的元素的函数。
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')
print( '调用 argmax() 函数：')
print( np.argmax(a))
print( '\n')
print( '展开数组：')
print( a.flatten())
print( '\n')
print( '沿轴 0 的最大值索引：')
maxindex = np.argmax(a, axis = 0)
print( maxindex)
print( '\n')
print( '沿轴 1 的最大值索引：')
maxindex = np.argmax(a, axis = 1)
print( maxindex)
print( '\n')
print( '调用 argmin() 函数：')
minindex = np.argmin(a)
print( minindex)
print( '\n')
print( '展开数组中的最小值：')
print( a.flatten()[minindex])
print( '\n')
print( '沿轴 0 的最小值索引：')
minindex = np.argmin(a, axis = 0)
print( minindex)
print( '\n')
print( '沿轴 1 的最小值索引：')
minindex = np.argmin(a, axis = 1)
print( minindex)
输出如下：
我们的数组是：
[[30 40 70]
[80 20 10]
[50 90 60]]
调用 argmax() 函数：
7
展开数组：
[30 40 70 80 20 10 50 90 60]
沿轴 0 的最大值索引：
[1 2 0]
沿轴 1 的最大值索引：
[2 0 1]
调用 argmin() 函数：
5
展开数组中的最小值：
10
沿轴 0 的最小值索引：
[0 1 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()
where()函数返回输入数组中满足给定条件的元素的索引。
示例
import numpy as np
x = np.arange(9.).reshape(3, 3)
print( '我们的数组是：')
print( x)
print( '大于 3 的元素的索引：')
y = np.where(x
>
3)
print( y)
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()
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.]
*附录
下面是引用互联网上对排序总结的一篇博客介绍：http://blog.csdn.net/pipisorry/article/details/51822775