#用于按列1排序

indexofsort=np.argsort(dataset[:,0],axis=-1,kind='stable') 
dataset   = dataset[indexofsort,:]

这是一个老问题，但如果你需要将其推广到高于2维的数组，下面是可以很容易推广的解决方案:

np.einsum('ij->ij', a[a[:,1].argsort(),:])

对于二维来说，这是一个过度的处理，对于@steve的答案，一个[a[:，1].argsort()]就足够了，但是这个答案不能推广到更高的维度。你可以在这个问题中找到一个3D数组的例子。

输出:

[[7 0 5]
 [9 2 3]
 [4 5 6]]

熊猫的方法只是为了完整性:

a = np.array([[9, 2, 3],
              [4, 5, 6],
              [7, 0, 5]])              
a = pd.DataFrame(a) 

             
a.sort_values(1, ascending=True).to_numpy()
array([[7, 0, 5], # '1' means sort by second column
       [9, 2, 3],
       [4, 5, 6]])

prl900 基准测试，与公认的答案相比:

%timeit pandas_df.sort_values(9, ascending=True)
1000 loops, best of 3: 400 µs per loop

%timeit numpy_table[numpy_table[:,9].argsort()]
10000 loops, best of 3: 180 µs per loop  

你可以按照Steve Tjoa的方法对多个列进行排序，使用像归并排序这样的稳定排序，并从最不重要的列到最重要的列对索引进行排序:

a = a[a[:,2].argsort()] # First sort doesn't need to be stable.
a = a[a[:,1].argsort(kind='mergesort')]
a = a[a[:,0].argsort(kind='mergesort')]

这是按第0列，第1列，第2列排序。

感谢这篇文章:https://stackoverflow.com/a/5204280/13890678

我用结构化数组找到了一个更“通用”的答案。 我认为这种方法的一个优点是代码更容易阅读。

import numpy as np
a = np.array([[9, 2, 3],
           [4, 5, 6],
           [7, 0, 5]])

struct_a = np.core.records.fromarrays(
    a.transpose(), names="col1, col2, col3", formats="i8, i8, i8"
)
struct_a.sort(order="col2")

print(struct_a)

[(7, 0, 5) (9, 2, 3) (4, 5, 6)]

一个稍微复杂一点的lexsort示例-在第一列降序，在第二列次级升序。lexsort的技巧是按行排序(因此使用. t)，并优先考虑最后一行。

In [120]: b=np.array([[1,2,1],[3,1,2],[1,1,3],[2,3,4],[3,2,5],[2,1,6]])
In [121]: b
Out[121]: 
array([[1, 2, 1],
       [3, 1, 2],
       [1, 1, 3],
       [2, 3, 4],
       [3, 2, 5],
       [2, 1, 6]])
In [122]: b[np.lexsort(([1,-1]*b[:,[1,0]]).T)]
Out[122]: 
array([[3, 1, 2],
       [3, 2, 5],
       [2, 1, 6],
       [2, 3, 4],
       [1, 1, 3],
       [1, 2, 1]])