Python total_ordering装饰器详解 - 自动补全比较方法

from functools import total_ordering

@total_ordering
class MyClass:
    def __eq__(self, other):
        ...

    def __lt__(self, other):
        ...

from functools import total_ordering

@total_ordering
class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __eq__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.score == other.score

    def __lt__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.score < other.score

    def __repr__(self):
        return f"Student({self.name}, {self.score})"

students = [
    Student('Alice', 85),
    Student('Bob', 92),
    Student('Charlie', 78),
    Student('David', 92),
]

# 使用自动补全的比较方法
print(f"Alice < Bob: {students[0] < students[1]}")
print(f"Alice >= Charlie: {students[0] >= students[2]}")
print(f"Bob == David: {students[1] == students[3]}")

sorted_students = sorted(students)
print(f"排序: {sorted_students}")

# 输出：
# Alice < Bob: True
# Alice >= Charlie: True
# Bob == David: True
# 排序: [Student(Charlie, 78), Student(Alice, 85), Student(Bob, 92), Student(David, 92)]

from functools import total_ordering

@total_ordering
class Version:
    def __init__(self, major, minor, patch):
        self.major = major
        self.minor = minor
        self.patch = patch

    def __eq__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)

    def __lt__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)

    def __repr__(self):
        return f"v{self.major}.{self.minor}.{self.patch}"

versions = [Version(2, 0, 0), Version(1, 9, 5), Version(2, 1, 0), Version(1, 10, 0)]
sorted_versions = sorted(versions)
print(f"排序后: {sorted_versions}")

v1 = Version(2, 0, 0)
v2 = Version(2, 1, 0)
print(f"{v1} <= {v2}: {v1 <= v2}")
print(f"{v1} > {v2}: {v1 > v2}")

# 输出：
# 排序后: [v1.9.5, v1.10.0, v2.0.0, v2.1.0]
# v2.0.0 <= v2.1.0: True
# v2.0.0 > v2.1.0: False

# 不使用 total_ordering，需要手动实现所有比较方法
class PointManual:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

    def __lt__(self, other):
        return (self.x, self.y) < (other.x, other.y)

    def __le__(self, other):
        return self < other or self == other

    def __gt__(self, other):
        return not self <= other

    def __ge__(self, other):
        return not self < other

# 使用 total_ordering，只需定义 __eq__ 和 __lt__
from functools import total_ordering

@total_ordering
class PointAuto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if not isinstance(other, PointAuto):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __lt__(self, other):
        if not isinstance(other, PointAuto):
            return NotImplemented
        return (self.x, self.y) < (other.x, other.y)

p1 = PointAuto(1, 2)
p2 = PointAuto(3, 4)
print(f"p1 < p2: {p1 < p2}")
print(f"p1 <= p2: {p1 <= p2}")
print(f"p1 > p2: {p1 > p2}")
print(f"p1 >= p2: {p1 >= p2}")

# 输出：
# p1 < p2: True
# p1 <= p2: True
# p1 > p2: False
# p1 >= p2: False