Python 比较操作符协议：`__eq__`, `__lt__` 等的实现与陷阱

好的，各位观众，欢迎来到今天的Python比较操作符协议“避坑指南”讲座！今天我们来聊聊Python里那些看似简单，实则暗藏玄机的比较操作符，比如__eq__，__lt__，等等。

开场白：比较操作符，你是我的眼？

在Python的世界里，比较操作符（比如==, <, >, !=, <=, >=）就像我们的眼睛，帮我们判断两个对象之间的关系。但是，如果你不了解它们的“脾气”，它们可能会让你看到一些“幻觉”。

第一幕：__eq__，等于不等于，是个问题

首先，我们来聊聊__eq__，也就是等于（==）操作符背后的故事。

默认行为：身份比较

如果你没有自定义__eq__方法，Python会使用默认的实现，也就是比较两个对象的身份（identity），也就是它们的内存地址。换句话说，只有当a is b为真时，a == b才会为真。
```
class MyClass:
    pass

a = MyClass()
b = MyClass()
c = a

print(a == b)  # 输出: False (不同的对象)
print(a == c)  # 输出: True (相同的对象)
```

自定义__eq__：内容比较

如果你想比较对象的内容，而不是身份，就需要自定义__eq__方法。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        if isinstance(other, Point):
            return self.x == other.x and self.y == other.y
        return False #与不是Point的类型比较，必须返回False，否则可能引起奇怪的问题

p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(3, 4)

print(p1 == p2)  # 输出: True (内容相同)
print(p1 == p3)  # 输出: False (内容不同)
print(p1 == (1,2)) # 输出: False (不是Point实例)

注意： __eq__方法必须返回一个布尔值（True或False）。此外，在和类型不匹配的对象比较时，一定要返回False，否则，可能会出问题。

__ne__：不等于的真相

__ne__方法代表不等于（!=）操作符。但是，如果你没有自定义__ne__方法，Python会默认使用not (a == b)的结果。也就是说，它会调用你的__eq__方法，然后取反。

class MyNumber:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        if isinstance(other, MyNumber):
            return self.value == other.value
        return False

num1 = MyNumber(5)
num2 = MyNumber(5)
num3 = MyNumber(10)

print(num1 != num2)  # 输出: False (因为 num1 == num2 为 True)
print(num1 != num3)  # 输出: True (因为 num1 == num3 为 False)

当然，你也可以自定义__ne__方法，但通常情况下，让Python自动帮你处理就足够了。

第二幕：富比较方法：__lt__, __gt__, __le__, __ge__

接下来，我们来聊聊其他的比较操作符：小于（<），大于（>），小于等于（<=），大于等于（>=）。它们对应的魔法方法分别是__lt__，__gt__，__le__，__ge__。

__lt__：小于的奥秘

__lt__方法定义了小于操作符的行为。

class MyString:
    def __init__(self, text):
        self.text = text

    def __lt__(self, other):
        if isinstance(other, MyString):
            return len(self.text) < len(other.text)
        return NotImplemented # 非常重要！

str1 = MyString("hello")
str2 = MyString("world")
str3 = MyString("hi")

print(str1 < str2)  # 输出: True (len("hello") < len("world"))
print(str1 < str3)  # 输出: False (len("hello") < len("hi"))

print(str1 < "abc") # 输出：TypeError: '<' not supported between instances of 'MyString' and 'str'

重点： 当你定义的比较操作符遇到无法处理的类型时，一定要返回NotImplemented。这告诉Python，你不负责处理这种类型的比较，让Python去尝试其他的比较方法（比如，如果右操作数定义了__gt__方法）。如果你不返回NotImplemented，而是直接抛出异常，可能会阻止Python尝试其他的比较方法，导致意想不到的结果。

__gt__，__le__，__ge__：举一反三

__gt__（大于），__le__（小于等于），__ge__（大于等于）方法的用法与__lt__类似。

class MyNumber:
    def __init__(self, value):
        self.value = value

    def __gt__(self, other):
        if isinstance(other, MyNumber):
            return self.value > other.value
        return NotImplemented

    def __le__(self, other):
        if isinstance(other, MyNumber):
            return self.value <= other.value
        return NotImplemented

    def __ge__(self, other):
        if isinstance(other, MyNumber):
            return self.value >= other.value
        return NotImplemented

num1 = MyNumber(5)
num2 = MyNumber(10)

print(num1 > num2)  # 输出: False
print(num1 <= num2) # 输出: True
print(num1 >= num2) # 输出: False

第三幕：functools.total_ordering：偷懒的艺术

如果你定义了__eq__方法，并且至少定义了__lt__，__le__，__gt__，__ge__中的一个，那么你可以使用functools.total_ordering装饰器来自动生成其他的比较方法。

from functools import total_ordering

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

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

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

s1 = Student("Alice", 85)
s2 = Student("Bob", 90)
s3 = Student("Charlie", 85)

print(s1 < s2)  # 输出: True
print(s1 > s2)  # 输出: False (自动生成)
print(s1 <= s3) # 输出: True (自动生成)
print(s1 >= s3) # 输出: True (自动生成)

functools.total_ordering会根据你提供的__eq__和__lt__方法，自动生成__gt__，__le__，__ge__方法。这可以减少你的代码量，提高代码的可读性。

第四幕：比较的陷阱和最佳实践

类型检查： 在比较方法中，一定要进行类型检查，确保你比较的是相同类型的对象。如果类型不匹配，一定要返回NotImplemented，或者返回False（对于__eq__），而不是直接抛出异常。
一致性： 确保你的比较方法是一致的。也就是说，如果a == b为真，那么b == a也应该为真。类似地，如果a < b为真，那么b > a应该为真。
传递性： 比较操作符应该满足传递性。也就是说，如果a < b且b < c，那么a < c应该为真。
避免副作用： 比较操作符不应该有任何副作用。也就是说，它们不应该修改对象的状态。
继承： 当你继承一个定义了比较操作符的类时，要小心。如果你需要修改比较行为，一定要重写所有的比较方法，或者使用functools.total_ordering装饰器。

表格总结

操作符	魔法方法	描述	默认行为
`==`	`__eq__`	等于	比较身份
`!=`	`__ne__`	不等于	`not (a == b)`
`<`	`__lt__`	小于	抛出 `TypeError`
`>`	`__gt__`	大于	抛出 `TypeError`
`<=`	`__le__`	小于等于	抛出 `TypeError`
`>=`	`__ge__`	大于等于	抛出 `TypeError`

示例：一个更复杂的例子

from functools import total_ordering

@total_ordering
class Version:
    def __init__(self, version_string):
        self.version_string = version_string
        self.parts = [int(x) for x in version_string.split(".")]

    def __eq__(self, other):
        if isinstance(other, Version):
            return self.parts == other.parts
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, Version):
            return self.parts < other.parts
        return NotImplemented

    def __repr__(self):
        return f"Version('{self.version_string}')"

v1 = Version("1.2.3")
v2 = Version("1.2.4")
v3 = Version("1.2.3")
v4 = Version("1.3.0")

print(v1 == v2) # False
print(v1 < v2)  # True
print(v1 > v2)  # False
print(v1 <= v3) # True
print(v4 > v2)  # True
print(v1 != v4) # True

#排序
versions = [v4, v1, v2]
versions.sort()
print(versions) # [Version('1.2.3'), Version('1.2.4'), Version('1.3.0')]

这个例子展示了如何比较版本号。我们将版本号字符串分割成数字列表，然后比较这些列表。使用total_ordering装饰器可以自动生成其他的比较方法。

彩蛋：__hash__方法

如果你自定义了__eq__方法，那么你也应该自定义__hash__方法。这是因为Python的哈希表（比如字典和集合）使用哈希值来快速查找对象。如果两个对象相等，那么它们的哈希值也必须相等。如果你只自定义了__eq__方法，而没有自定义__hash__方法，Python会发出警告，并且你的对象可能无法在哈希表中正常工作。

class MyObject:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        if isinstance(other, MyObject):
            return self.value == other.value
        return False

    def __hash__(self):
        return hash(self.value)

obj1 = MyObject(5)
obj2 = MyObject(5)

print(obj1 == obj2) # True

my_set = {obj1, obj2} # 如果不定义 __hash__，会发出警告
print(len(my_set)) # 1 (因为 obj1 和 obj2 相等，所以它们在集合中只出现一次)

总结：比较操作符，谨慎使用

Python的比较操作符协议看似简单，实则暗藏玄机。理解它们的行为，避免常见的陷阱，才能写出健壮、可靠的代码。记住，类型检查，一致性，传递性，避免副作用，以及NotImplemented，都是你成功的关键。

最后，希望今天的讲座能帮助你更好地理解Python的比较操作符协议。感谢大家的观看！下次再见！

Python 比较操作符协议：`eq`, `lt` 等的实现与陷阱

发表回复取消回复

发表回复 取消回复

发表回复取消回复