Python 对于二维数组，按顺序逐列排序的最佳方法是什么？

假设我有一个

mx3

2D阵列，我想要的是：

首先根据数组的最后一列（索引为2的列）对数组进行排序

查找最后一列中所有值相同的数组切片，根据中间的列对每个数组切片排序。

查找行中最后两列中的两个值相同的所有数组切片，根据第一列对每个数组切片进行排序

这种排序的一个例子如下

下面是我提出的解决方案，它基本上实现了快速排序算法：

def quicksort(array, c_ind, begin=0, end=None):
    
    def _partition(array, c_ind, begin, end):
        pivot = begin
        for i in range(begin+1, end+1):
            if array[i][c_ind] <= array[begin][c_ind]:
                pivot += 1
                array[i], array[pivot] = array[pivot], array[i]
        array[pivot], array[begin] = array[begin], array[pivot]
        
        return pivot
    
    def _quicksort(array, c_ind, begin, end):    
        if begin >= end: return
        pivot = _partition(array, c_ind, begin, end)
        _quicksort(array, c_ind, begin, pivot-1)
        _quicksort(array, c_ind, pivot+1, end)
        
    if end is None: end = len(array)-1
        
    return _quicksort(array, c_ind, begin, end)


def solver(array):
    
    num_columns = len(array[0])
    for column_ind in range(num_columns)[::-1]:
        
        if column_ind == num_columns - 1:
            quicksort(array,c_ind=column_ind)
        else:
            for post_ind in range(len(posts)-1):
                quicksort(array,c_ind=column_ind,begin=posts[post_ind],end=posts[post_ind+1]-1)
    
        posts = [0]
        for row_ind,row in enumerate(array):
            if row_ind == 0: 
                previous_val = tuple([row[c_idx] for c_idx in range(column_ind,num_columns)[::-1]])
            if row_ind > 0:
                if tuple([row[c_idx] for c_idx in range(column_ind,num_columns)[::-1]]) != previous_val:
                    posts.append(row_ind)
                previous_val = tuple([row[c_idx] for c_idx in range(column_ind,num_columns)[::-1]])
        posts.append(len(array))        
            
array = [[1,1,1,0,0,2,3,1,4],[0,0,0,0,0,0,1,1,1],[1,1,2,3,4,5,1,1,1]]
print(np.array(array).T,'\n')
array = np.array(array).T.tolist()

solver(array)
np.array(array)

def快速排序（数组，索引，开始=0，结束=None）：
定义分区（数组、索引、开始、结束）：
枢轴=开始
对于范围内的i（开始+1，结束+1）：
如果数组[i][c_ind]=end:return
pivot=\u分区（数组、索引、开始、结束）
_快速排序（数组、c_ind、begin、pivot-1）
_快速排序（数组、索引、轴+1、结束）
如果end为None:end=len（数组）-1
返回快速排序（数组、索引、开始、结束）
def解算器（阵列）：
num\u columns=len（数组[0]）
对于范围内的列（num_columns）[：-1]：
如果列\u ind==num\u列-1：
快速排序（数组，c_ind=列_ind）
其他：
对于范围内的立柱索引（长度（立柱）-1）：
快速排序（数组，c_ind=列_ind，开始=帖子[post_ind]，结束=帖子[post_ind+1]-1）
职位=[0]
对于行索引，枚举（数组）中的行：
如果行_ind==0：
previous_val=元组（[row[c_idx]用于范围内的c_idx（column_ind，num_columns）[：：-1]]））
如果行索引>0：
如果元组（[row[c_idx]用于范围内的c_idx（column_ind，num_columns）[：：-1]]）！=上一次会议：
posts.append（行索引）
previous_val=元组（[row[c_idx]用于范围内的c_idx（column_ind，num_columns）[：：-1]]））
posts.append（len（数组））
数组=[[1,1,1,0,0,2,3,1,4]，[0,0,0,0,0,0,0,1,1,1]，[1,1,2,3,4,5,1,1,1]]
打印（np.array（array.T，“\n”）
array=np.array（array）.T.tolist（）
解算器（阵列）
np.数组（数组）

我做对了吗？更重要的是，是否有一个

numpy

模块可以为我实现这一点？

您可以使用lexsort：

array[np.lexsort((array[:,-3],array[:,-2],array[:,-1]))]

或等效（尤其是对于较大的阵列）：

例如：

array = 
[[1 0 1]
 [1 0 1]
 [1 0 2]
 [0 0 3]
 [0 0 4]
 [2 0 5]
 [3 1 1]
 [1 1 1]
 [4 1 1]]

输出：

[[1 0 1]
 [1 0 1]
 [1 1 1]
 [3 1 1]
 [4 1 1]
 [1 0 2]
 [0 0 3]
 [0 0 4]
 [2 0 5]]

---

查看

np.lexsort

。结构化数组也可以进行这种排序。

[[1 0 1]
 [1 0 1]
 [1 1 1]
 [3 1 1]
 [4 1 1]
 [1 0 2]
 [0 0 3]
 [0 0 4]
 [2 0 5]]