小编点评

**numpy 数组排序** **1. 排序算法** - `sort` 函数：封装了多种排序算法，默认排序算法是 `quicksort`。 - `argsort` 函数：返回排序后的索引，用于获取排序后的结果。 **2. 行列排序** - `axis=0`：按行排序。 - `axis=1`：按列排序。 **3. 部分排序** - `partition` 函数：可以根据特定索引或条件对数组进行部分排序。 **4. 总结** - numpy 的排序提供了一种快速、灵活、可靠的排序方式。 - 针对数组做了更多的优化，排序效率比 Python 内置排序算法更高。 - 选择合适的排序算法和参数来进行数据排序。

正文

numpy 数组通常是用于数值计算的多维数组，而排序功能可以快速、准确地对数据进行排序，从而得到更加清晰、易于分析的结果。

在数据分析和处理过程中，常常需要对数据进行排序，以便更好地理解和发现其中的规律和趋势。

排序会应用在很多场景中，比如：

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

1. 排序算法

1.1. sort 函数

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

import numpy as np

arr = np.random.randint(0, 100, 10)
print(arr)
#运行结果
[44 11 36  0 83 90 54 40 36 34]

arr.sort(kind='quicksort')
print(arr)
#运行结果
[ 0 11 34 36 36 40 44 54 83 90]

arr.sort(kind='mergesort')
print(arr)
#运行结果
[ 0 11 34 36 36 40 44 54 83 90]

arr.sort(kind='heapsort')
print(arr)
#运行结果
[ 0 11 34 36 36 40 44 54 83 90]

arr.sort(kind='stable')
print(arr)
#运行结果
[ 0 11 34 36 36 40 44 54 83 90]

四种排序算法分别是：

1. quicksort：快速排序
2. mergesort：归并排序
3. heapsort：堆排序
4. stable：冒泡排序

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

1.2. argsort 函数

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

arr = np.random.randint(0, 100, 10)
print(arr)
#运行结果
[71 59 96 30 71 24 22 60 99 94]

print(arr.argsort())
#运行结果
[6 5 3 1 7 0 4 9 2 8]

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

2. 行列排序

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

arr = np.random.randint(0, 100, (3, 3))
print(arr)
#运行结果
[[14 18  6]
 [80 85 14]
 [95 24 82]]

arr.sort(axis=0)
print(arr)
#运行结果
[[14 18  6]
 [80 24 14]
 [95 85 82]]

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

arr = np.random.randint(0, 100, (3, 3))
print(arr)
#运行结果
[[ 2 22 17]
 [85  6 20]
 [98 97 39]]

arr.sort(axis=1)
print(arr)
#运行结果
[[ 2 17 22]
 [ 6 20 85]
 [39 97 98]]

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

注意：这种排序的方式会破坏原有元素之间的行列关系。

3. 部分排序

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

arr = np.random.randint(0, 100, 10)
print(arr)
#运行结果
[13 94 71  6 47 81 99 12 49 20]

arr.partition(3)
print(arr)
#运行结果
[ 6 13 12 20 94 81 99 71 49 47]

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

多维数组也可以部分排序：

arr = np.random.randint(0, 100, (5, 5))
print(arr)
#运行结果
[[11  8 84 34 99]
 [24 18 69 79 41]
 [ 2 25 91 91 64]
 [64  8 48 86 49]
 [68 62 51 22 85]]

arr.partition(3, axis=0)
print(arr)
#运行结果
[[ 2  8 48 22 49]
 [11  8 51 34 64]
 [24 18 69 79 41]
 [64 25 84 86 85]
 [68 62 91 91 99]]

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

arr = np.random.randint(0, 100, (5, 5))
print(arr)
#运行结果
[[76 79 72 91 98]
 [13 58 53 76 63]
 [57 98 16 81 39]
 [48 43 63 98 77]
 [33 71 54 74 68]]

arr.partition(3, axis=1)
print(arr)
#运行结果
[[72 76 79 91 98]
 [13 53 58 63 76]
 [16 39 57 81 98]
 [43 48 63 77 98]
 [33 54 68 71 74]]

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

4. 总结回顾

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