怎么在Python类中实现运算符重载？__add__等方法详解

在Python中，实现运算符重载的核心途径是在自定义类中重写特定的双下划线特殊方法（即魔术方法）。当表达式中出现 +、- 或 * 等操作符时，Python解释器会自动将其分发为对应左操作数或右操作数的特定方法调用。例如，执行 a + b 时，解释器会优先尝试调用 a.__add__(b)。掌握运算符重载不仅能让自定义对象的语法更贴近内置类型，更是构建矩阵计算、几何向量、物理度量单位以及符号表达式等数据抽象模型的基石。

一、运算符重载的核心机制与基础加法（__add__）

Python中的所有数据类型都是一等公民对象，运算符实质上是对底层C-API或魔术方法的语法糖。要让一个自定义类支持加法运算符 +，最基础的做法是在类中实现 __add__(self, other) 方法。

在设计 __add__ 时，必须保证运算逻辑的严谨性：一方面，加法通常应遵循“不可变计算”原则，即返回一个新的实例，而不是在原对象上做就地修改；另一方面，当传入未知的操作数类型时，不应武断地抛出 TypeError，而应当返回预置的单例对象 NotImplemented，将运算控制权让渡给后续的回退流程。

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

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

    def __add__(self, other):
        # 严格验证操作数类型
        if isinstance(other, Vector2D):
            return Vector2D(self.x + other.x, self.y + other.y)
        # 类型不匹配时返回NotImplemented，交由Python触发后续反向方法或报错
        return NotImplemented

# 运行验证
v1 = Vector2D(2, 3)
v2 = Vector2D(4, 5)
print(v1 + v2)  # 输出示例：Vector2D(6.0, 8.0)

二、反向运算（__radd__）与就地运算（__iadd__）

仅实现 __add__ 并不足以支持所有自然的加法场景。例如，当我们需要支持“标量与向量相加”时，表达式 v1 + 5 会成功触发 v1.__add__(5)；但若写成 5 + v1，左操作数整数 5 的 int.__add__ 并不认识自定义的 Vector2D，此时内置的加法会返回 NotImplemented。

为了拯救这种运算，Python提供了反向方法机制。在 int.__add__ 放弃后，解释器会转而寻找右操作数 v1 的 __radd__(self, other) 方法。如果实现了 __radd__，就可以无缝支持交换律。

此外，复合赋值运算符 += 对应的是就地方法 __iadd__(self, other)。如果一个类没有定义 __iadd__，Python会自动退化为 a = a + b，即先调用 __add__ 创建一个全新对象并重新绑定变量名。但对于允许内部状态修改的可变容器（如列表），通过 __iadd__ 进行内存级就地修改能显著节约内存分配与垃圾回收的开销。

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

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

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

    # 反向加法：当 other + self 发生且 other 无法处理 self 时被调用
    def __radd__(self, other):
        # 加法满足交换律，直接委托给 __add__ 处理
        return self.__add__(other)

    # 就地加法：支持 v += other
    def __iadd__(self, other):
        if isinstance(other, Vector2D):
            self.x += other.x
            self.y += other.y
            return self  # 就地操作必须显式返回 self
        if isinstance(other, (int, float)):
            self.x += other
            self.y += other
            return self
        return NotImplemented

# 运行验证
v = Vector2D(10, 20)
print(v + 5)    # 触发 __add__  -> Vector2D(15.0, 25.0)
print(5 + v)    # 触发 __radd__ -> Vector2D(15.0, 25.0)

v += Vector2D(1, 1) # 触发 __iadd__ 原地修改
print(v)        # 输出：Vector2D(11.0, 21.0)

三、常见运算符映射表与富比较（Rich Comparisons）

Python提供了完整的运算符重载协议。除了加法外，算术、位运算以及比较运算都有一一对应的双下划线方法。下表梳理了高频使用的基础运算符及其魔术方法：

比较运算符与 @total_ordering 装饰器

对于比较运算符（小于、等于、大于等），Python使用“富比较”（Rich Comparisons）机制。六个比较运算分别映射为：__eq__（==）、__ne__（!=）、__lt__（<）、__le__（<=）、__gt__（>）、__ge__（>=）。

逐一手工编写六个比较方法不仅冗长，而且容易出现逻辑冲突（例如 a < b 与 a >= b 结果不互斥）。标准库 functools 模块提供了 @total_ordering 类装饰器。我们只需定义好 __eq__，再加上 __lt__、__le__、__gt__ 或 __ge__ 中的任意一个，该装饰器便会自动利用数学对偶关系补全剩余的比较运算。

四、综合实战：构建支持重载的物理量度（Quantity）类

为了将加法、乘法、反向运算与富比较串联起来，我们以一个工程中常见的“带单位物理量（Quantity）”为例。该类需要满足以下实际需求：

1. 相同单位的物理量可以相加相减，单位不同时抛出异常。
2. 物理量可以与标量（int/float）进行乘法缩放，且同时支持 q * 3 与 3 * q。
3. 支持大小比较，便于进行阈值判定与序列排序。

from functools import total_ordering

@total_ordering
class Quantity:
    def __init__(self, value: float, unit: str):
        self.value = float(value)
        self.unit = str(unit).strip()

    def __repr__(self) -> str:
        return f"{self.value}{self.unit}"

    # 1. 加法与减法：仅支持同单位运算
    def __add__(self, other):
        if not isinstance(other, Quantity):
            return NotImplemented
        if self.unit != other.unit:
            raise ValueError(f"单位不匹配无法相加: '{self.unit}' 与 '{other.unit}'")
        return Quantity(self.value + other.value, self.unit)

    def __sub__(self, other):
        if not isinstance(other, Quantity):
            return NotImplemented
        if self.unit != other.unit:
            raise ValueError(f"单位不匹配无法相减: '{self.unit}' 与 '{other.unit}'")
        return Quantity(self.value - other.value, self.unit)

    # 2. 乘法：物理量与标量缩放
    def __mul__(self, other):
        if isinstance(other, (int, float)):
            return Quantity(self.value * other, self.unit)
        return NotImplemented

    # 反向乘法：支持 2.5 * q 形式
    def __rmul__(self, other):
        return self.__mul__(other)

    # 3. 比较运算符
    def __eq__(self, other):
        if not isinstance(other, Quantity):
            return NotImplemented
        return self.value == other.value and self.unit == other.unit

    def __lt__(self, other):
        if not isinstance(other, Quantity):
            return NotImplemented
        if self.unit != other.unit:
            raise TypeError(f"不同单位之间无法比较大小: '{self.unit}' 和 '{other.unit}'")
        return self.value < other.value

# 步骤验证
length_a = Quantity(15.5, "m")
length_b = Quantity(4.5, "m")

# 测试加减与标量乘
total = length_a + length_b
scaled = 2 * total
print(f"相加结果: {total}")        # 输出：相加结果: 20.0m
print(f"双向标量乘: {scaled}")      # 输出：双向标量乘: 40.0m

# 测试比较与排序
items = [Quantity(25, "kg"), Quantity(10, "kg"), Quantity(18, "kg")]
print(f"排序前: {items}")
print(f"排序后: {sorted(items)}")   # 输出：[10.0kg, 18.0kg, 25.0kg]

五、运算符重载的三大注意事项与避坑指南