怎么在Python类中通过双下划线函数实现运算符重载

陆景行

发布时间：2026-10-27| 8人浏览过

原创

在Python中，实现运算符重载的核心途径是在自定义类中定义相应的“双下划线方法”（也称特殊方法或魔术方法，Dunder Methods）。当两个对象执行 +、-、* 或 == 等运算时，Python解释器会在底层将这些运算符自动转译为对应的特殊方法调用。本文将以一个直观的二维向量（Vector）类贯穿始终，全面拆解算术运算、反向运算、富比较运算以及就地运算的具体实现步骤与核心规范。

怎么在Python类中通过双下划线函数实现运算符重载 — 图1：Python运算符解析与双下划线方法转译关系

一、核心机制：运算符与双下划线方法的对应关系

在Python设计哲学中，运算符并不与具体的基础数据类型硬绑定，而是通过特定协议开放给所有类。当你写下表达式 a + b 时，解释器首先查找 type(a) 是否实现了 __add__ 方法。如果实现了，则执行 type(a).__add__(a, b)。

根据运算性质，常用的双下划线函数可以划分为四大核心类别：

运算符类别	常见运算符	对应特殊方法	典型应用语义
正向算术运算	`+`, `-`, `*`, `/`	`__add__`, `__sub__`, `__mul__`, `__truediv__`	创建并返回两个对象运算后的全新实例
反向算术运算	`+`, `-`, `*`, `/`	`__radd__`, `__rsub__`, `__rmul__`, `__rtruediv__`	当左侧操作数不支持当前运算时由右侧对象兜底执行
就地修改运算	`+=`, `-=`, `*=`	`__iadd__`, `__isub__`, `__imul__`	允许可变对象直接在原内存上修改并返回 `self`
富比较运算	`==`, `!=`, `<`, `<=`	`__eq__`, `__ne__`, `__lt__`, `__le__`	比较对象属性值，返回布尔值（`True` / `False`）

二、步骤教学：以二维向量类实现基础算术重载

为了让重载逻辑清晰可复现，我们定义一个表示数学向量的 Vector 类，实现向量坐标的加法运算。实现运算符重载应遵循三个标准化步骤。

第1步：搭建基础类并实现可视化打印方法

为了验证运算结果，先定义构造函数 __init__ 以及友好的控制台展示函数 __repr__：

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

    def __repr__(self):
        # 提供清晰的类表达形式，便于交互调试
        return f"Vector({self.x}, {self.y})"

第2步：实现加法方法 `add` 并加入类型判定

在类中定义 __add__ 函数。关键原则是：必须严格校验右侧操作数 other 的类型。如果不属于支持的类型，必须返回全局单例 NotImplemented，而不是直接抛出 TypeError。

    def __add__(self, other):
        # 严格检查类型：只有当 other 也是 Vector 时才执行坐标相加
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        # 遇到未知类型，返回 NotImplemented 让解释器尝试其他备用路径
        return NotImplemented

第3步：验证重载效果与非法类型处理

完成编写后，通过实例测试正常运算与类型不匹配时的行为：

# 正常场景：两向量相加
v1 = Vector(2, 4)
v2 = Vector(3, 1)
v3 = v1 + v2
print(v3)  # 输出示例：Vector(5, 5)

# 异常场景：与不支持的整数相加
try:
    v4 = v1 + 10
except TypeError as e:
    print("捕获错误:", e)
    # 输出示例：捕获错误: unsupported operand type(s) for +: 'Vector' and 'int'

三、运行机制：双向调度与 NotImplemented 决策流

为什么推荐返回 NotImplemented 而非直接抛出异常？这是因为Python具备双向运算符调度机制。在处理二元运算 a + b 时，解释器并不只依赖左操作数，而是拥有一套完整的回退与重试链条。

四、反向运算支持：实现标量与向量的乘法

考虑向量乘以数字的场景。假设期望同时支持 v * 3 和 3 * v。对于前者，Python调用 v.__mul__(3)；但对于后者，由于左侧是内置整型 int，int 并不知道如何与自定义的 Vector 进行乘法计算，因此 int.__mul__(3, v) 会返回 NotImplemented。

此时，Python解释器会立即将运算控制权反转给右操作数，调用 Vector 实例的 __rmul__（Reflected Multiplication）方法。以下是具体实现：

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

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

    def __mul__(self, scalar):
        # 支持向量与数字（int 或 float）相乘
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented

    def __rmul__(self, scalar):
        # 标量乘法满足交换律，直接委托给 __mul__
        return self.__mul__(scalar)

通过实现 __rmul__，不论数字位于乘号左侧还是右侧，代码都能平滑运行：

v = Vector(3, 4)
print(v * 2)  # 输出示例：Vector(6, 8)（触发 __mul__）
print(3 * v)  # 输出示例：Vector(9, 12)（触发 int 失败后回退至 __rmul__）

五、比较运算符重载与全序排序

在默认情况下，两个自定义类实例使用 == 比较时，Python比较的是两者的内存ID（即 id(a) == id(b)）。若要按照业务属性（例如向量坐标数值）判定相等，必须重载 __eq__。

此外，如果还需要支持大小比较（如 <、<=、>、>=），不需要手动编写全部4个函数。借助标准库 functools.total_ordering 装饰器，只需定义 __eq__ 与任意一个有序方法（通常为 __lt__），装饰器就会自动为类推导补齐其余比较运算符。

from functools import total_ordering
import math

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

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

    def _magnitude(self):
        # 辅助计算模长
        return math.hypot(self.x, self.y)

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

    def __lt__(self, other):
        # 按照向量长度进行大小比较
        if isinstance(other, Vector):
            return self._magnitude() < other._magnitude()
        return NotImplemented

验证全序比较逻辑：

v1 = Vector(3, 4)  # 模长 5
v2 = Vector(1, 1)  # 模长 约 1.414
print(v1 == Vector(3, 4))  # 输出示例：True
print(v1 > v2)             # 输出示例：True（自动通过 __lt__ 反转计算）
print(v2 <= v1)            # 输出示例：True（自动合成 __le__）

六、就地运算符重载：`iadd` 的作用与注意事项

对于复合赋值运算符（如 +=），Python通过 __iadd__ 特殊方法提供支持。如果类中没有定义 __iadd__，Python会自动将 a += b 降级展开为 a = a + b，即调用现有的 __add__ 并生成新对象赋予原变量名。

但在需要追求极致性能或处理可变集合（如列表追加）时，自定义 __iadd__ 可以避免反复创建新实例。编写 __iadd__ 必须遵守一条黄金准则：必须在方法末尾返回 self。

    def __iadd__(self, other):
        if isinstance(other, Vector):
            self.x += other.x
            self.y += other.y
            return self  # 必须返回自身引用以维持连续赋值
        return NotImplemented

七、工程实践中的避坑要点与规范

在企业级开发或开源类库中重载运算符时，还需遵守以下四项核心工程规范：

区分 NotImplemented 与 TypeError： 在特殊方法中遇到未知类型，切勿直接 raise TypeError。抛出异常会中断Python解释器的调度链条，导致右操作数的反向方法失去执行机会。始终 return NotImplemented，由解释器在所有尝试均失败后统一抛出规范的 TypeError。
遵循不变性与纯函数约定： 二元算术运算（如 __add__、__mul__）应当产生一个全新的对象，切忌在运算过程中就地修改 self 的属性。原位修改会导致意想不到的副作用与难以排查的引用共享Bug。
重载 `__eq__` 时的哈希同步问题： Python中一旦在类中自定义了 __eq__，解释器会自动将该类的 __hash__ 设为 None，使其变为不可哈希对象（即无法放入 set 或作为 dict 的键）。如果你的对象在创建后是不可变的，并且需要作为字典键使用，必须同步显式重载 __hash__。
保持符合常理的领域语义： 运算符重载应当符合数学直觉或通用业务习惯。不要为了省写代码而将无数学关联的操作（例如将“发送HTTP请求”重载为 >>）强行绑定到运算符上，过度重载会严重削弱代码的可读性与可维护性。