Python 自定义比较器

比如现在有二维空间中的3个点，需要按照指定规则对它们进行排序：先按x坐标排序，如果相同，则按y坐标排序。

自定义比较项

通过修改key=参数，使用lambda将输入的元素映射成一个值，这个值就代表了这个元素的大小。

arr = sorted(l, key=lambda t : 1000 * t.x + t.y)
print_list(arr)

自定义比较方法

通过修改key=参数，并借助内置的cmp_to_key，重写对两个元素的比较方法。

可以直接将坐标的比较规则用代码写出来（可以新建一个函数，也可以直接使用lambda），作为新的比较方法。

from functools import cmp_to_key
def cmp(t1, t2):
    """
    比较函数，需要满足：t1>t2则返回正数，t1=t0则返回0，t1
    if t1.x == t2.x:
        return t1.y - t2.y
    return t1.x - t2.x
    """

# 新建cmp函数    
arr = sorted(l, key=cmp_to_key(cmp))
print_list(arr)

# 使用lambda
arr_ = sorted(l, key=cmp_to_key(lambda a, b : a.x - b.x if a.x != b.x else a.y - b.y))

print_list(arr_)

自定义运算符

在类中重写比较函数，然后可以直接使用常规的比较运算符来判断两个对象（都属于这个类）的大小。

运算符

• __lt__: <
• __gt__: >
• __ge__: >=
• __eq__: ==
• __le__: <=

重写类方法

这样的话，就可以将 Pos 类当做简单的基本类型数值，可以直接进行比较大小，也适用于所有排序方法。

class MySort:
    def __init__(self, x = 0, y = 0):
        self.x = x
        self.y = y
 
    def __str__(self):
        return ('(%s, %s)' % (self.x, self.y))
 
    def __lt__(self, other):
        return self.x < other.x if self.x != other.x else self.y < other.y
 
    def __gt__(self, other):
        return self.x > other.x if self.x != other.x else self.y > other.y
 
    def __ge__(self, other):
        return self.x >= other.x if self.x != other.x else self.y >= other.y
 
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
 
    def __le__(self, other):
        return self.x <= other.x if self.x != other.x else self.y <= other.y

-- 测试自定义运算符
print(MySort(5, 1) > MySort(2, 4)) -- 输出 True
print(MySort(5, 2) < MySort(5, 1)) -- 输出 False

-- 排序
arr = sorted(l)
print_list(arr)