【numpy基础】--数组排序

东郭延君

numpy 数组通常是用于数值计算的多维数组，而排序功能可以快速、准确地对数据进行排序，从而得到更加清晰、易于分析的结果。
在数据分析和处理过程中，常常需要对数据进行排序，以便更好地理解和发现其中的规律和趋势。
排序会应用在很多场景中，比如：

• 数据分类：将数据按照一定的特征进行分类，可以通过 numpy 数组排序来实现。
  
• 数据筛选：通过 numpy 数组排序，可以快速地筛选出符合特定条件的数据。
  
• 数据合并：多个 numpy 数组可以通过 numpy 数组排序来进行合并，从而得到一个更加完整、准确的数据集。
  

1. 排序算法

1.1. sort 函数

numpy中常用排序算法都是封装好的，通过 sort函数，可以直接使用常用的排序算法。

1. import numpy as np
3. arr = np.random.randint(0, 100, 10)
4. print(arr)
5. #运行结果
6. [44 11 36  0 83 90 54 40 36 34]
8. arr.sort(kind='quicksort')
9. print(arr)
10. #运行结果
11. [ 0 11 34 36 36 40 44 54 83 90]
13. arr.sort(kind='mergesort')
14. print(arr)
15. #运行结果
16. [ 0 11 34 36 36 40 44 54 83 90]
18. arr.sort(kind='heapsort')
19. print(arr)
20. #运行结果
21. [ 0 11 34 36 36 40 44 54 83 90]
23. arr.sort(kind='stable')
24. print(arr)
25. #运行结果
26. [ 0 11 34 36 36 40 44 54 83 90]

复制代码

四种排序算法分别是：

• quicksort：快速排序
  
• mergesort：归并排序
  
• heapsort：堆排序
  
• stable：冒泡排序
  

上述排序的结果都一样，quicksort 是默认的排序算法，也是效率最高的算法。
1.2. argsort 函数

除了 sort 函数，还有一个比较常用的是 argsort，它返回的是排序之后的索引。

1. arr = np.random.randint(0, 100, 10)
2. print(arr)
3. #运行结果
4. [71 59 96 30 71 24 22 60 99 94]
6. print(arr.argsort())
7. #运行结果
8. [6 5 3 1 7 0 4 9 2 8]

复制代码

argsort 的结果是排序之后的原数组的下标。
比如第一个值 6 表示的是 arr[6]，也就是 22。
2. 行列排序

当数组是多维的时候，可以按照每个维度来排序。
比如二维数组：

1. arr = np.random.randint(0, 100, (3, 3))
2. print(arr)
3. #运行结果
4. [[14 18  6]
5. [80 85 14]
6. [95 24 82]]
8. arr.sort(axis=0)
9. print(arr)
10. #运行结果
11. [[14 18  6]
12. [80 24 14]
13. [95 85 82]]

复制代码

axis=0 是跨行的意思，也就是按列对数据进行排序。

1. arr = np.random.randint(0, 100, (3, 3))
2. print(arr)
3. #运行结果
4. [[ 2 22 17]
5. [85  6 20]
6. [98 97 39]]
8. arr.sort(axis=1)
9. print(arr)
10. #运行结果
11. [[ 2 17 22]
12. [ 6 20 85]
13. [39 97 98]]

复制代码

axis=1 是跨列的意思，也就是按行对数据进行排序。
注意：这种排序的方式会破坏原有元素之间的行列关系。
3. 部分排序

nunpy的数组还支持部分排序，也就是只针对数组的特定部分排序，不用对整个数组排序。

1. arr = np.random.randint(0, 100, 10)
2. print(arr)
3. #运行结果
4. [13 94 71  6 47 81 99 12 49 20]
6. arr.partition(3)
7. print(arr)
8. #运行结果
9. [ 6 13 12 20 94 81 99 71 49 47]

复制代码

partition(3)表示的把最小的三个数字放在数组前三个，后面的元素就是原先剩下的元素，顺序不管。
放在最前面的三个数是所有元素中最小的三个数，它们的顺序也是不保证的。
多维数组也可以部分排序：

1. arr = np.random.randint(0, 100, (5, 5))
2. print(arr)
3. #运行结果
4. [[11  8 84 34 99]
5. [24 18 69 79 41]
6. [ 2 25 91 91 64]
7. [64  8 48 86 49]
8. [68 62 51 22 85]]
10. arr.partition(3, axis=0)
11. print(arr)
12. #运行结果
13. [[ 2  8 48 22 49]
14. [11  8 51 34 64]
15. [24 18 69 79 41]
16. [64 25 84 86 85]
17. [68 62 91 91 99]]

复制代码

partition之后，数组的前三行元素就是每列最小的三个数。

1. arr = np.random.randint(0, 100, (5, 5))
2. print(arr)
3. #运行结果
4. [[76 79 72 91 98]
5. [13 58 53 76 63]
6. [57 98 16 81 39]
7. [48 43 63 98 77]
8. [33 71 54 74 68]]
10. arr.partition(3, axis=1)
11. print(arr)
12. #运行结果
13. [[72 76 79 91 98]
14. [13 53 58 63 76]
15. [16 39 57 81 98]
16. [43 48 63 77 98]
17. [33 54 68 71 74]]

复制代码

partition之后，数组的前三列元素就是每行最小的三个数。
4. 总结回顾

numpy 数组排序提供了一种快速、灵活、可靠的排序方式，可以满足各种排序需求。
numpy的排序针对数组做了更多的优化，排序效率比python内置的排序算法更高。

来源:https://www.cnblogs.com/wang_yb/p/17522409.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！