怎么在Python自定义类中实现运算符重载？

在Python中实现自定义类的运算符重载，核心做法是在类中显式定义以双下划线命名的特殊方法（俗称魔术方法或Dunder Methods），例如实现加法定义 __add__、等于判断定义 __eq__、小于比较定义 __lt__。当程序对该类实例执行加号、减号或比对等操作符时，Python解释器会在底层自动分发并调用对应的特殊方法，从而赋予自定义对象像内置整数、浮点数或列表一样直接进行运算的能力。

一、运算符重载的核心概念与执行步骤

Python并没有引入任何特殊的语法糖来声明运算符，而是通过对象协议机制将每个运算符硬编码绑定到特定的方法名称上。实现一个符合直觉且健壮的运算符重载通常遵循固定的五步流程：明确运算符语义、定义对应的特殊方法签名、对传入的操作数执行类型校验、运算后返回全新的对象实例、编写断言进行单元验证。

基础示例：二维向量 Vector2D 的加法重载

为了直观展示上述步骤，我们以图形学与数学计算中常见的“二维向量”类为例。若没有运算符重载，两个向量相加只能定义类似 v1.add(v2) 的方法；而通过重载 __add__，可以直接书写 v3 = v1 + v2：

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

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

    # 重载加法运算符: +
    def __add__(self, other):
        # 步骤3: 类型检查，非预期类型返回 NotImplemented
        if not isinstance(other, Vector2D):
            return NotImplemented
        
        # 步骤4: 运算后返回新实例，绝不修改自身属性
        return Vector2D(self.x + other.x, self.y + other.y)

# 示例验证
v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)
v3 = v1 + v2
print(v3)  # 输出: Vector2D(4, 6)

二、Python解释器如何解析二元运算符

很多初学者容易误以为 a + b 只是单纯执行 a.__add__(b)，但在Python的完整对象模型中，运算解析包含双向协作与优雅回退机制。理解该底层原理是编写高健壮性代码的前提。

支持反射运算：处理混合类型乘法

假设我们希望向量支持与数字相乘：v * 3。此时 v 作为左操作数调用 __mul__。但如果我们写 3 * v，左操作数是整数 3，它的 int.__mul__ 无法识别自定义的 Vector2D 并返回 NotImplemented。此时Python就会自动转向右操作数 v 的 __rmul__（反向乘法方法）：

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

    # 正向乘法: v * 3
    def __mul__(self, other):
        if not isinstance(other, (int, float)):
            return NotImplemented
        return Vector2D(self.x * other, self.y * other)

    # 反向乘法: 3 * v
    def __rmul__(self, other):
        # 乘法满足交换律，直接委托给正向 __mul__
        return self.__mul__(other)

# 验证双向乘法
v = Vector2D(2, 5)
print(v * 3)  # 调用 __mul__ -> Vector2D(6, 15)
print(4 * v)  # 调用 __rmul__ -> Vector2D(8, 20)

三、常见运算符重载方法对照与接口规范

Python提供了完整的运算符协议族，涵盖算术运算、比较运算、位运算及就地赋值运算。在实现时必须遵循特定的签名与返回值约定。

比较运算符实现与 @total_ordering 简化

重载比较运算符时，如果手动编写 __eq__、__ne__、__lt__、__le__、__gt__、__ge__ 全部6个方法不仅繁琐，而且容易出现逻辑不一致。标准库 functools 提供了 @total_ordering 装饰器，只需要实现 __eq__ 以及 __lt__、__le__、__gt__、__ge__ 中的任意一个，即可由Python自动补全其余比较方法：

from functools import total_ordering

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

    # 计算模长平方
    def _magnitude_sq(self):
        return self.x ** 2 + self.y ** 2

    # 重载相等判断: ==
    def __eq__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    # 重载小于比较: < (按模长排序)
    def __lt__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return self._magnitude_sq() < other._magnitude_sq()

# 验证自动补全的比较操作
v1 = Vector2D(1, 1)  # 模长平方: 2
v2 = Vector2D(2, 2)  # 模长平方: 8

print(v1 < v2)   # True (调用 __lt__)
print(v1 <= v2)  # True (由 total_ordering 自动合成)
print(v1 > v2)   # False (由 total_ordering 自动合成)
print(v1 == v2)  # False (调用 __eq__)

四、避坑指南与最佳实践决策树

运算符重载虽然提升了代码的简洁度，但不当的使用往往会引入深层隐患。在实际工程落地时，应严格对照下述决策标准进行设计。

特别注意事项：__hash__ 与 __eq__ 的联动机制

在Python中，一个对象如果要放入 set 集合，或者作为 dict 的键（Key），它必须是“可哈希的”（Hashable）。默认情况下，自定义类通过内存地址进行哈希和比对。

注意：一旦你在类中显式重写了 __eq__，Python为了防止破坏哈希表的一致性（即如果 a == b，则必须保证 hash(a) == hash(b)），会自动将该类的 __hash__ 属性置为 None。这意味着该类的实例将无法直接存入集合或作为字典键。

如果你的类逻辑上是不可变的（Immutable），且需要放进集合，必须显式重写 __hash__ 方法：

class Vector2D:
    def __init__(self, x, y):
        self._x = x
        self._y = y

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

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

    # 显式重写哈希函数，使用所有参与相等比对的属性组合
    def __hash__(self):
        return hash((self.x, self.y))

# 验证集合去重
vec_set = {Vector2D(1, 2), Vector2D(1, 2), Vector2D(3, 4)}
print(len(vec_set))  # 输出: 2 (相同向量成功去重)

五、总结

在Python自定义类中实现运算符重载的核心路径十分清晰：

1. 按需映射：根据业务与数学模型选择对应的双下划线特殊方法（__add__、__sub__、__eq__ 等）。
2. 尊重回退：在方法内部对操作数类型进行校验，遇到不支持的类型时务必返回 NotImplemented，而不是直接抛出 TypeError，以确保Python反射机制正常运转。
3. 保持纯粹：算术运算符始终构造并返回新对象，杜绝在运算过程中原地改变操作数状态。
4. 配合装饰器与哈希：比较操作优先使用 @total_ordering；若重写了 __eq__ 且需支持集合操作，同步实现 __hash__。

遵循这套规范，既能让自定义对象具备极高雅的数学表达力，又能保证代码在面对复杂调用链和混合类型计算时具备良好的健壮性与可维护性。