如何实现对象的比较操作（__eq__, __lt__等）？-Python教程-PHP中文网

要实现自定义对象的比较，需定义富比较方法如__eq__、__lt__等，确保类型检查时返回NotImplemented，并通过functools.total_ordering简化代码；若重写__eq__，还需正确实现__hash__以保证对象可哈希，尤其在对象不可变时基于相等属性计算哈希值；对于包含列表或嵌套对象的复杂结构，递归利用元素自身的比较方法进行深度比较，确保逻辑一致性和正确性。

如何实现对象的比较操作（__eq__, __lt__等）？

在Python中，要让你的自定义对象能够像内置类型一样进行比较，比如判断相等（

==

登录后复制

）、小于（

登录后复制

）或大于（

登录后复制

），核心就在于实现一系列所谓的“富比较方法”（rich comparison methods），也就是那些以双下划线开头和结尾的特殊方法，比如

__eq__

登录后复制

、

__lt__

登录后复制

、

__gt__

登录后复制

等。通过定义这些方法，你实际上是在告诉Python解释器，当遇到你的对象进行比较操作时，它应该如何“理解”并执行这些操作。这就像给你的对象赋予了生命，让它们拥有了内在的“大小”和“身份”概念。

解决方案

实现对象的比较操作，主要依赖于Python的特殊方法（也称为“魔法方法”或“dunder methods”）。这些方法允许你自定义对象在特定操作下的行为。对于比较操作，主要的有：

```
__eq__(self, other)
```
登录后复制
: 定义相等操作符
```
==
```
登录后复制
的行为。
```
__ne__(self, other)
```
登录后复制
: 定义不相等操作符
```
!=
```
登录后复制
的行为。通常，如果你实现了
```
__eq__
```
登录后复制
，
```
__ne__
```
登录后复制
可以直接返回
```
not self.__eq__(other)
```
登录后复制
。
```
__lt__(self, other)
```
登录后复制
: 定义小于操作符
```
<
```
登录后复制
的行为。
```
__le__(self, other)
```
登录后复制
: 定义小于等于操作符
```
<=
```
登录后复制
的行为。
```
__gt__(self, other)
```
登录后复制
: 定义大于操作符
```
>
```
登录后复制
的行为。
```
__ge__(self, other)
```
登录后复制
: 定义大于等于操作符
```
>=
```
登录后复制
的行为。

当你在类中定义了这些方法后，Python在进行比较时会优先调用它们。一个很重要的点是，这些方法应该在无法进行有效比较时返回

NotImplemented

登录后复制

，而不是

False

登录后复制

或抛出异常。返回

NotImplemented

登录后复制

会告诉Python尝试调用

other

登录后复制

对象的相应反向比较方法（例如，如果

a.__eq__(b)

登录后复制

NotImplemented

登录后复制

，Python会尝试

b.__eq__(a)

登录后复制

）。

下面是一个简单的例子，我们创建一个

Point

登录后复制

类，并为其实现

__eq__

登录后复制

和

__lt__

登录后复制

方法：

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented # 告诉Python，我们不知道怎么和非Point对象比较
        return self.x == other.x and self.y == other.y

    def __lt__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        # 这里我们定义一个简单的比较规则：先比x，x相同再比y
        if self.x < other.x:
            return True
        if self.x == other.x and self.y < other.y:
            return True
        return False

# 测试
p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(2, 1)
p4 = Point(1, 3)

print(f"p1 == p2: {p1 == p2}") # True
print(f"p1 == p3: {p1 == p3}") # False
print(f"p1 < p3: {p1 < p3}")   # True (1 < 2)
print(f"p1 < p4: {p1 < p4}")   # True (x相同，2 < 3)
print(f"p3 < p1: {p3 < p1}")   # False (2不小于1)
print(f"p1 != p3: {p1 != p3}") # True (因为__eq__返回False，所以!=是True)

# 尝试与不同类型比较
print(f"p1 == 'hello': {p1 == 'hello'}") # False (因为NotImplemented，然后Python决定它们不相等)

登录后复制

可以看到，一旦我们定义了

__eq__

登录后复制

和

__lt__

登录后复制

，Python就能理解我们的对象了。对于

__le__

登录后复制

、

__gt__

登录后复制

、

__ge__

登录后复制

，如果你觉得重复实现有点麻烦，Python标准库提供了一个非常实用的装饰器

functools.total_ordering

登录后复制

。只要你实现了

__eq__

登录后复制

和至少一个其他排序方法（如

__lt__

登录后复制

、

__le__

登录后复制

、

__gt__

登录后复制

、

__ge__

登录后复制

中的一个），

total_ordering

登录后复制

就能帮你自动填充其余的比较方法，这大大减少了样板代码。

from functools import total_ordering

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

    def __repr__(self):
        return f"PointWithTotalOrdering({self.x}, {self.y})"

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

    def __lt__(self, other):
        if not isinstance(other, PointWithTotalOrdering):
            return NotImplemented
        if self.x < other.x:
            return True
        if self.x == other.x and self.y < other.y:
            return True
        return False

# 测试
p_a = PointWithTotalOrdering(1, 2)
p_b = PointWithTotalOrdering(1, 3)
p_c = PointWithTotalOrdering(2, 1)

print(f"p_a <= p_b: {p_a <= p_b}") # True (total_ordering自动生成)
print(f"p_c > p_a: {p_c > p_a}")   # True (total_ordering自动生成)

登录后复制

这样一来，代码会更简洁，也更不容易出错。

__eq__

登录后复制

和

__hash__

登录后复制

之间有什么关系？为什么它们很重要？

这其实是个挺有意思的话题，因为

__eq__

登录后复制

和

__hash__

登录后复制

经常被一起提起，并且它们之间有着非常严格的约定。简单来说，如果两个对象根据

__eq__

登录后复制

方法判断是相等的，那么它们的

__hash__

登录后复制

值也必须相等。反之，如果

__hash__

登录后复制

值不同，它们肯定不相等。这个约定是Python内部机制（比如字典和集合）能够正确工作的基石。

为什么这么说呢？你想啊，字典（

dict

登录后复制

）和集合（

set

登录后复制

）这类数据结构，它们的查找和存储效率之所以高，就是因为它内部使用了哈希表。当你把一个对象作为字典的键或者添加到集合中时，Python会先计算这个对象的哈希值（通过调用它的

__hash__

登录后复制

方法），然后根据这个哈希值找到对应的存储位置。

如果你的

__eq__

登录后复制

方法判断两个对象相等，但它们的

__hash__

登录后复制

值却不同，那问题就大了。比如你把

obj1

登录后复制

加到集合里，Python计算它的哈希值是

H1

登录后复制

。然后你又创建了一个

obj2

登录后复制

，它和

obj1

登录后复制

是相等的（

obj1 == obj2

登录后复制

是

True

登录后复制

），但它的哈希值却是

H2

登录后复制

。当你尝试用

obj2

登录后复制

去查找

obj1

登录后复制

时，Python会先计算

obj2

登录后复制

的哈希值

H2

登录后复制

，然后去

H2

登录后复制

对应的位置找，结果当然是找不到

obj1

登录后复制

了，即使它们逻辑上是相等的。这显然违背了我们的直觉。

所以，Python有这么几条规则：

如果一个类不定义
```
__eq__
```
登录后复制
方法，那么它默认继承
```
object
```
登录后复制
的
```
__eq__
```
登录后复制
，这个默认实现是基于对象ID（内存地址）的，也就是说只有同一个对象实例才相等。同时，它也默认继承
```
object
```
登录后复制
的
```
__hash__
```
登录后复制
，哈希值也是基于对象ID的。这种情况下，
```
__eq__
```
登录后复制
和
```
__hash__
```
登录后复制
是保持一致的。
如果你在类中自定义了
```
__eq__
```
登录后复制
方法，但没有定义
```
__hash__
```
登录后复制
方法，那么Python会默认将
```
__hash__
```
登录后复制
设置为
```
None
```
登录后复制
。这意味着你的对象将变得不可哈希（unhashable），不能作为字典的键或集合的元素。这是Python为了避免上述不一致性而做出的安全策略。
如果你既定义了
```
__eq__
```
登录后复制
又定义了
```
__hash__
```
登录后复制
，那么你就必须确保：如果
```
obj1 == obj2
```
登录后复制
为真，那么
```
hash(obj1) == hash(obj2)
```
登录后复制
也必须为真。通常，
```
__hash__
```
登录后复制
的实现会基于那些用于判断相等的属性。

举个例子，如果我们的

Point

登录后复制

类是可变的（比如允许修改

登录后复制

和

登录后复制

），那么它就不应该实现

__hash__

登录后复制

，或者明确地将其设置为

None

登录后复制

，因为它可变，哈希值也可能变，这会破坏哈希表的完整性。但如果

Point

登录后复制

是不可变的，我们可以这样实现

__hash__

登录后复制

：

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

    def __repr__(self):
        return f"ImmutablePoint({self.x}, {self.y})"

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

    def __hash__(self):
        # 使用tuple的hash方法，因为tuple是不可变的，并且其hash值由内部元素决定
        return hash((self.x, self.y))

p1 = ImmutablePoint(1, 2)
p2 = ImmutablePoint(1, 2)
p3 = ImmutablePoint(2, 1)

my_set = {p1, p3}
print(f"Set before adding p2: {my_set}") # {ImmutablePoint(1, 2), ImmutablePoint(2, 1)}
my_set.add(p2) # p2和p1相等，哈希值也相等，所以不会重复添加
print(f"Set after adding p2: {my_set}")  # {ImmutablePoint(1, 2), ImmutablePoint(2, 1)}

my_dict = {p1: "first point"}
print(f"Dict with p1: {my_dict}") # {ImmutablePoint(1, 2): 'first point'}
print(f"Accessing dict with p2: {my_dict[p2]}") # 'first point' (因为p2和p1相等且哈希值相同)

登录后复制

你看，一旦

__hash__

登录后复制

被正确实现，我们的对象就能在哈希表中正常工作了。这是一个非常重要的细节，尤其是在设计那些需要作为字典键或集合元素的自定义对象时。

实现比较操作时，有哪些常见的陷阱或最佳实践？

说实话，实现这些比较方法，看似简单，但里面坑还真不少。我个人觉得，最容易踩的几个坑，以及一些可以让你少走弯路的小技巧，值得我们聊聊。

常见的陷阱：

类型检查不足或错误处理： 这是最常见的。很多人在
```
__eq__
```
登录后复制
或
```
__lt__
```
登录后复制
中直接假设
```
other
```
登录后复制
对象就是我们期望的类型，然后直接访问
```
other.x
```
登录后复制
、
```
other.y
```
登录后复制
。如果
```
other
```
登录后复制
是一个完全不相关的类型，比如一个字符串或数字，那就会直接抛出
```
AttributeError
```
登录后复制
。正确的做法是，首先检查
```
other
```
登录后复制
的类型，如果类型不匹配，应该返回
```
NotImplemented
```
登录后复制
。

Calliper 文档对比神器
文档内容对比神器

28

查看详情
```
# 错误示范
# def __eq__(self, other):
#     return self.x == other.x and self.y == other.y # 如果other不是Point，会出错

# 正确做法
def __eq__(self, other):
    if not isinstance(other, MyClass): # 或者 type(other) is MyClass
        return NotImplemented
    # ... 比较逻辑 ...
```
登录后复制
返回
```
NotImplemented
```
登录后复制
而不是
```
False
```
登录后复制
，这很重要。
```
NotImplemented
```
登录后复制
告诉Python“我不知道怎么比较，你问问对方试试看？” 如果你返回
```
False
```
登录后复制
，那就意味着你明确表示它们不相等，但实际上可能是无法比较。
不一致的比较逻辑： 比如你定义了
```
__lt__
```
登录后复制
，但没有定义
```
__gt__
```
登录后复制
，或者它们之间的逻辑是矛盾的。例如，
```
a < b
```
登录后复制
是
```
True
```
登录后复制
，但
```
b > a
```
登录后复制
却是
```
False
```
登录后复制
。这会让你的对象行为变得非常难以预测，尤其是在排序算法中。
```
functools.total_ordering
```
登录后复制
就是为了解决这个问题的最佳实践，它能保证你定义一个基础的比较逻辑后，其他相关的比较方法都能保持一致。
递归比较的死循环： 如果你的对象内部包含相同类型的其他对象，并且你的比较逻辑是递归的，那么就得小心了。比如一个
```
Node
```
登录后复制
对象包含一个
```
next_node
```
登录后复制
属性，而
```
next_node
```
登录后复制
又是
```
Node
```
登录后复制
类型，在
```
__eq__
```
登录后复制
中如果不加限制地递归比较，可能会导致无限循环。通常需要设定一个比较深度限制，或者在比较时记录已经访问过的对象，避免重复比较。
忘记
```
__hash__
```
登录后复制
的约定： 前面已经详细说过了，如果你重写了
```
__eq__
```
登录后复制
，但没有正确处理
```
__hash__
```
登录后复制
，那你的对象就不能用在字典或集合里，或者会造成数据结构混乱。这是非常隐蔽且后果严重的陷阱。

最佳实践：

始终进行类型检查并返回
```
NotImplemented
```
登录后复制
：无论什么时候实现比较方法，都应该把
```
isinstance(other, MyClass)
```
登录后复制
放在第一行，并根据结果返回
```
NotImplemented
```
登录后复制
。这不仅健壮，也符合Python的协议。
利用
```
functools.total_ordering
```
登录后复制
：如果你的对象需要支持所有六种排序操作（
```
<
```
登录后复制
,
```
<=
```
登录后复制
,
```
==
```
登录后复制
,
```
!=
```
登录后复制
,
```
>
```
登录后复制
,
```
>=
```
登录后复制
），强烈建议使用
```
@functools.total_ordering
```
登录后复制
装饰器。你只需要实现
```
__eq__
```
登录后复制
和任意一个排序方法（比如
```
__lt__
```
登录后复制
），其他方法都会被自动生成，并且保证逻辑一致性。这能让你省下大量重复代码，并且降低出错的概率。
明确“相等”的定义： 在开始编写
```
__eq__
```
登录后复制
之前，先想清楚，在你的业务逻辑中，什么样的两个对象才算“相等”？是所有属性都相等？还是只有关键ID相等？这个定义会直接影响你的
```
__eq__
```
登录后复制
实现，并且也间接影响
```
__hash__
```
登录后复制
。
保持对象不可变性（如果可能）： 如果你的对象是不可变的，那么实现
```
__hash__
```
登录后复制
会更容易且更安全。不可变对象在哈希表中的行为是稳定的。如果你的对象是可变的，那么通常就不应该实现
```
__hash__
```
登录后复制
，或者只在那些“逻辑上”不可变的属性上计算哈希值，但这会比较复杂。
为调试提供良好的
```
__repr__
```
登录后复制
：虽然这不是直接的比较操作，但一个清晰的
```
__repr__
```
登录后复制
方法在调试比较问题时非常有帮助。它能让你一眼看出对象的当前状态，从而更容易理解为什么两个对象被判断为相等或不相等。

如何为包含复杂结构（如列表、嵌套对象）的自定义对象实现比较？

当我们的自定义对象不仅仅是几个简单属性的集合，而是包含了列表、字典，甚至是其他自定义对象实例时，实现比较操作就变得稍微复杂一些了。这时候，你的比较逻辑需要能够“深入”到这些复杂结构内部去。这其实是一个递归或者说迭代的过程。

我们来设想一个

Playlist

登录后复制

类，它里面包含了一个歌曲列表，而每首歌曲又是一个

Song

登录后复制

类的实例。现在，我们想判断两个

Playlist

登录后复制

是否相等。

首先，定义我们的

Song

登录后复制

类，它需要有自己的比较逻辑：

@total_ordering
class Song:
    def __init__(self, title, artist, duration_seconds):
        self.title = title
        self.artist = artist
        self.duration_seconds = duration_seconds

    def __repr__(self):
        return f"Song(title='{self.title}', artist='{self.artist}', duration={self.duration_seconds}s)"

    def __eq__(self, other):
        if not isinstance(other, Song):
            return NotImplemented
        return (self.title == other.title and
                self.artist == other.artist and
                self.duration_seconds == other.duration_seconds)

    def __lt__(self, other):
        if not isinstance(other, Song):
            return NotImplemented
        # 按照标题、艺术家、时长顺序比较
        return ((self.title, self.artist, self.duration_seconds) <
                (other.title, other.artist, other.duration_seconds))

    def __hash__(self):
        # 歌曲通常是不可变的，可以哈希
        return hash((self.title, self.artist, self.duration_seconds))

登录后复制

现在，我们有了

Song

登录后复制

类的比较能力。接下来，我们构建

Playlist

登录后复制

类。它的

__eq__

登录后复制

方法不仅要比较播放列表的名称，还要逐个比较其内部的

songs

登录后复制

列表。

class Playlist:
    def __init__(self, name, songs=None):
        self.name = name
        self.songs = list(songs) if songs is not None else []

    def __repr__(self):
        return f"Playlist(name='{self.name}', songs={self.songs})"

    def add_song(self, song):
        if isinstance(song, Song):
            self.songs.append(song)
        else:
            raise TypeError("Only Song objects can be added to a playlist.")

    def __eq__(self, other):
        if not isinstance(other, Playlist):
            return NotImplemented

        # 首先比较播放列表的名称
        if self.name != other.name:
            return False

        # 然后比较歌曲列表
        # 这里的关键是：列表的比较操作会委托给列表中元素的__eq__方法
        # 并且列表长度也必须相同
        if len(self.songs) != len(other.songs):
            return False

        # 逐个比较列表中的歌曲
        # 注意：Python列表默认的__eq__就是按元素顺序和__eq__进行比较的
        # 所以我们可以直接用列表的相等判断
        return self.songs == other.songs

    # 如果需要排序，也需要实现__lt__

登录后复制

以上就是如何实现对象的比较操作（__eq__, __lt__等）？的详细内容，更多请关注php中文网其它相关文章！