运算符重载 (Operator Overloading) 允许自定义类的实例对标准运算符（如 +, -, *, /, ==, <, [] 等）作出响应。通过在自定义类中定义特定的魔术方法 (Magic Methods) 或称 双下划线方法 (Dunder Methods)，我们可以改变这些运算符的行为，使其适用于我们自己定义的对象。这使得自定义类的实例能够像内置类型一样自然地进行操作，提高了代码的可读性和表达力。

核心思想：通过实现 Python 的特殊方法 (以双下划线 __ 开头和结尾)，我们可以控制自定义对象如何响应内置运算符和函数。这些特殊方法是 Python 语言的“钩子”，允许我们自定义对象的行为。

一、为什么需要运算符重载？

考虑一个场景：我们正在创建一个表示二维向量的 Vector 类。如果没有运算符重载，我们可能需要这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def add(self, other): # 自定义方法进行向量加法
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        else:
            raise TypeError("Can only add Vector to Vector")

v1 = Vector(1, 2)
v2 = Vector(3, 4)

v3 = v1.add(v2) # 必须调用方法
print(f"v3 = ({v3.x}, {v3.y})") # 输出：v3 = (4, 6)

这样的代码虽然功能正确，但 v1.add(v2) 不如 v1 + v2 来得直观和符合数学习惯。通过运算符重载，我们可以让 Vector 对象支持 + 运算符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other): # 重载 + 运算符
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        else:
            raise TypeError("Unsupported operand type for +")

    def __repr__(self): # 用于更友好的打印输出
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)

v3 = v1 + v2 # 使用 + 运算符
print(f"v3 = {v3}") # 输出：v3 = Vector(4, 6)

显然，重载后的代码更具 Pythonic 风格，增强了可读性和表达力。

二、核心概念：魔术方法 (Dunder Methods)

运算符重载的实现依赖于 Python 的魔术方法，它们是类中以双下划线 __ 开始和结束的特殊方法。当 Python 解释器遇到特定的语法结构或函数调用时，会自动查找并调用对象相应的魔术方法。

例如：

  • v1 + v2 会调用 v1.__add__(v2)。
  • len(my_list) 会调用 my_list.__len__()。
  • str(my_obj) 会调用 my_obj.__str__()。

理解这些魔术方法是掌握 Python 运算符重载的关键。

三、常用运算符重载分类与方法

运算符重载可以分为几大类：算术运算符、比较运算符、一元运算符、增强赋值运算符、序列/映射操作符等。

3.1 算术运算符

运算符 魔术方法 (左操作数) 魔术方法 (右操作数) 描述
+ __add__(self, other) __radd__(self, other) 加法
- __sub__(self, other) __rsub__(self, other) 减法
* __mul__(self, other) __rmul__(self, other) 乘法
/ __truediv__(self, other) __rtruediv__(self, other) 真除法
// __floordiv__(self, other) __rfloordiv__(self, other) 整除法
% __mod__(self, other) __rmod__(self, other) 取模
** __pow__(self, other) __rpow__(self, other) 幂运算
<< __lshift__(self, other) __rlshift__(self, other) 左移
>> __rshift__(self, other) __rrshift__(self, other) 右移
& __and__(self, other) __rand__(self, other) 按位与
| __or__(self, other) __ror__(self, other) 按位或
^ __xor__(self, other) __rxor__(self, other) 按位异或

__add__ 与 __radd__ 的区别：

  • 当执行 a + b 时，如果 a 实现了 __add__，则调用 a.__add__(b)。
  • 如果 a 没有实现 __add__ 或 __add__ 返回 NotImplemented，Python 会尝试调用 b.__radd__(a)。
  • 这使得运算符在操作数类型不同时也能正常工作（例如 int + Vector）。

示例：Vector 类的加法和乘法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented # 表示不支持此操作

    def __mul__(self, scalar): # 向量与标量乘法
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented

    def __rmul__(self, scalar): # 反向乘法，如 2 * Vector(1,2)
        return self.__mul__(scalar)

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2
print(f"v1 + v2 = {v3}") # Vector(4, 6)

v4 = v1 * 3
print(f"v1 * 3 = {v4}") # Vector(3, 6)

v5 = 2 * v2 # 2 是 int 类型，会调用 v2.__rmul__(2)
print(f"2 * v2 = {v5}") # Vector(6, 8)

3.2 比较运算符

运算符 魔术方法 描述
== __eq__(self, other) 等于
!= __ne__(self, other) 不等于
< __lt__(self, other) 小于
<= __le__(self, other) 小于或等于
> __gt__(self, other) 大于
>= __ge__(self, other) 大于或等于

示例：Point 类的比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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 NotImplemented

    def __lt__(self, other): # 判断是否小于 (按X坐标，再按Y坐标)
        if isinstance(other, Point):
            return self.x < other.x or (self.x == other.x and self.y < other.y)
        return NotImplemented

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

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

print(f"p1 == p2: {p1 == p2}") # True
print(f"p1 != p3: {p1 != p3}") # True
print(f"p1 < p3: {p1 < p3}")   # True
print(f"p3 > p1: {p3 > p1}")   # True

注意：通常只需要实现 __eq__ 和 __lt__ (或 __le__ 等)，Python 可以通过这些来推断其他比较操作 (__gt__, __ge__, __ne__)。特别是，如果实现了 __eq__，__ne__ 默认会返回 not self.__eq__(other)。

3.3 一元运算符

运算符 魔术方法 描述
+ __pos__(self) 正号
- __neg__(self) 负号
~ __invert__(self) 按位取反
abs() __abs__(self) 绝对值

示例：Vector 类的负号和绝对值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import math

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

    def __neg__(self): # 负向量
        return Vector(-self.x, -self.y)

    def __abs__(self): # 向量的模
        return math.sqrt(self.x**2 + self.y**2)

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

v = Vector(3, -4)
print(f"-v = {-v}")     # Vector(-3, 4)
print(f"abs(v) = {abs(v)}") # 5.0

3.4 增强赋值运算符 (In-place Operators)

运算符 魔术方法 描述
+= __iadd__(self, other) 加法并赋值
-= __isub__(self, other) 减法并赋值
*= __imul__(self, other) 乘法并赋值
//= __ifloordiv__(self, other) 整除法并赋值
… (其他类似)

注意：

  • 这些方法应该修改 self 对象并返回 self。
  • 如果一个类没有实现增强赋值方法，Python 会尝试调用对应的算术运算符方法 (__add__ 等) 并将结果赋值给原变量。例如，如果 __iadd__ 不存在，a += b 会尝试 a = a + b。

示例：Vector 类的增强加法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __iadd__(self, other): # 增强加法
        if isinstance(other, Vector):
            self.x += other.x
            self.y += other.y
            return self # 必须返回 self
        return NotImplemented

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)

v1 += v2 # 调用 __iadd__
print(f"v1 after += v2: {v1}") # Vector(4, 6)

3.5 序列和映射操作符

运算符 魔术方法 描述
len() __len__(self) 长度
obj[key] __getitem__(self, key) 获取元素
obj[key] = value __setitem__(self, key, value) 设置元素
del obj[key] __delitem__(self, key) 删除元素
key in obj __contains__(self, item) 成员检测
迭代器 __iter__(self) 返回迭代器
reversed() __reversed__(self) 反向迭代器

示例：Playlist 类的序列操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class Song:
    def __init__(self, title, artist):
        self.title = title
        self.artist = artist
    def __repr__(self):
        return f"Song('{self.title}', '{self.artist}')"

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

    def __len__(self): # 实现 len()
        return len(self._songs)

    def __getitem__(self, index): # 支持索引和切片
        return self._songs[index]

    def __setitem__(self, index, value): # 支持修改元素
        if not isinstance(value, Song):
            raise TypeError("Playlist can only contain Song objects")
        self._songs[index] = value

    def __delitem__(self, index): # 支持删除元素
        del self._songs[index]

    def __contains__(self, song): # 支持 'in' 运算符
        return song in self._songs

    def __iter__(self): # 支持迭代
        return iter(self._songs)

    def add_song(self, song):
        if not isinstance(song, Song):
            raise TypeError("Can only add Song objects")
        self._songs.append(song)

    def __repr__(self):
        return f"Playlist({len(self._songs)} songs)"

s1 = Song("Bohemian Rhapsody", "Queen")
s2 = Song("Stairway to Heaven", "Led Zeppelin")
s3 = Song("Hotel California", "Eagles")

my_playlist = Playlist([s1, s2])

print(f"Playlist length: {len(my_playlist)}") # 2
print(f"First song: {my_playlist[0]}") # Song('Bohemian Rhapsody', 'Queen')

my_playlist[1] = s3 # 修改第二个元素
print(f"Updated playlist: {my_playlist[1]}") # Song('Hotel California', 'Eagles')

my_playlist.add_song(Song("Imagine", "John Lennon"))
print(f"Playlist length after add: {len(my_playlist)}") # 3

print(f"Is s1 in playlist: {s1 in my_playlist}") # True
print(f"Is Song('Imagine', 'John Lennon') in playlist: {Song('Imagine', 'John Lennon') in my_playlist}") # False, 因为是新对象

# 迭代
print("Songs in playlist:")
for song in my_playlist:
    print(song)

del my_playlist[0] # 删除第一个元素
print(f"Playlist length after del: {len(my_playlist)}") # 2

3.6 类型转换和字符串表示

函数/语法 魔术方法 描述
str(obj) __str__(self) 用于用户友好的字符串表示 (通常用于 print())
repr(obj) __repr__(self) 用于开发人员友好的字符串表示 (通常用于调试，理想情况下返回一个可以重新创建对象的字符串)
bytes(obj) __bytes__(self) 转换为字节串
bool(obj) __bool__(self) 转换为布尔值 (如果未实现，会尝试 __len__)
int(obj) __int__(self) 转换为整数
float(obj) __float__(self) 转换为浮点数

示例：Vector 类的字符串表示和布尔值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self): # 用户友好的字符串表示
        return f"<{self.x}, {self.y}>"

    def __repr__(self): # 开发人员友好的字符串表示
        return f"Vector({self.x}, {self.y})"

    def __bool__(self): # 转换为布尔值，非零向量为 True
        return self.x != 0 or self.y != 0

v_non_zero = Vector(1, 2)
v_zero = Vector(0, 0)

print(v_non_zero)       # <1, 2> (调用 __str__)
print(repr(v_non_zero)) # Vector(1, 2) (调用 __repr__)
print(f"Is v_non_zero true? {bool(v_non_zero)}") # True
print(f"Is v_zero true? {bool(v_zero)}")         # False

3.7 上下文管理器 (with 语句)

语法 魔术方法 描述
with obj: __enter__(self) 进入 with 块时调用，返回上下文对象
__exit__(self, exc_type, exc_val, exc_tb) 退出 with 块时调用，处理异常

示例：FileHandler 类的上下文管理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class FileHandler:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        print(f"Entering context: Opening file {self.filename} in mode {self.mode}")
        self.file = open(self.filename, self.mode)
        return self.file # 返回文件对象供 with 语句使用

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Exiting context: Closing file {self.filename}")
        if self.file:
            self.file.close()
        # 如果 __exit__ 返回 True，则表示已处理异常，不再向外抛出
        # 否则，如果发生异常，异常会继续传播
        return False # 不处理异常，让其传播

# 使用自定义的上下文管理器
with FileHandler("my_log.txt", "w") as f:
    f.write("Hello from FileHandler!\n")
    # raise ValueError("Something went wrong!") # 尝试抛出异常

print("File handling complete.")

# 验证文件是否已创建和关闭
with open("my_log.txt", "r") as f:
    print(f.read())

四、运算符重载的最佳实践和注意事项

  1. 保持语义一致性：重载运算符时，请确保其行为与内置类型的相应运算符的预期行为一致。例如，+ 运算符应该用于合并或相加操作，而不是随机的用途。过度或不当的重载会使代码难以理解和维护。
  2. 返回新对象：对于算术运算符（如 +, -, *），通常应该返回一个新的对象，而不是修改当前对象（除非是增强赋值运算符 += 等）。这是为了保持数据不变性，避免副作用。
  3. 处理不同类型操作数：在魔术方法中，要检查 other 参数的类型。如果不支持与特定类型的操作，应返回 NotImplemented（而不是抛出 TypeError），以便 Python 解释器有机会尝试调用 other 对象的反向魔术方法。
  4. __eq__ 与 __hash__：如果自定义类实现了 __eq__ 方法，并且打算将对象用作字典的键或集合的元素，那么通常也需要实现 __hash__ 方法。如果两个对象相等 (a == b 为 True)，它们的 hash() 值必须相等。可变对象不应该实现 __hash__。
  5. __repr__ 和 __str__：始终为自定义类实现 __repr__，它应该返回一个清晰、无歧义的字符串表示，理想情况下是一个可以重新创建对象的字符串。__str__ 用于用户友好的输出。
  6. collections.abc 模块：如果自定义类旨在模拟内置容器类型（如列表、字典），可以继承 collections.abc 模块中的抽象基类 (ABC)，例如 MutableSequence 或 Mapping。这能确保实现所有必要的魔术方法，并提供类型检查的便利。
  7. 避免副作用：运算符重载的目的是让代码更简洁和直观。避免在重载的运算符中引入复杂的业务逻辑或副作用。

五、总结

Python 的运算符重载通过魔术方法为自定义类提供了极大的灵活性和表达力。它允许我们以自然、直观的方式与对象进行交互，使得自定义类型能够无缝融入 Python 的生态系统。然而，正确和负责任地使用运算符重载至关重要。遵循最佳实践，确保运算符行为的语义一致性，并妥善处理不同类型操作数，才能真正发挥其优势，写出既强大又易于理解的 Python 代码。