Python操作符的重载

Python 中的操作符重载（operator overloading）是一种让用户定义的对象可以使用标准操作符（如 +、-、* 等）进行运算的特性。通过操作符重载，我们可以让自定义的类实例在使用这些操作符时，表现出特定的行为。

1、操作符重载的基本概念

在 Python 中，操作符实际上是调用了某些特殊的方法。这些特殊方法以双下划线 __ 开头和结尾。例如，+ 操作符实际上是调用 __add__ 方法。

当你创建一个自定义类时，你可以定义这些特殊方法来实现操作符的重载。这样，操作符就可以在你的对象上进行自定义的操作。

1.1、常用的操作符重载方法

1.1.1、算术操作符

• __add__(self, other)：用于 + 操作符
• __sub__(self, other)：用于 - 操作符
• __mul__(self, other)：用于 * 操作符
• __truediv__(self, other)：用于 / 操作符
• __floordiv__(self, other)：用于 // 操作符
• __mod__(self, other)：用于 % 操作符
• __pow__(self, other)：用于 ** 操作符

1.1.2、比较操作符

• __eq__(self, other)：用于 == 操作符
• __ne__(self, other)：用于 != 操作符
• __lt__(self, other)：用于 < 操作符
• __le__(self, other)：用于 <= 操作符
• __gt__(self, other)：用于 > 操作符
• __ge__(self, other)：用于 >= 操作符

1.1.3、比其他操作符

• __getitem__(self, key)：用于 obj[key]
• __setitem__(self, key, value)：用于 obj[key] = value
• __delitem__(self, key)：用于 del obj[key]
• __call__(self, *args, **kwargs)：用于 obj(*args, **kwargs)
• __str__(self)：用于 str(obj) 和 print(obj)
• __repr__(self)：用于 repr(obj)

1.2、例子

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

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

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

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

# 使用 Vector 类
v1 = Vector(2, 3)
v2 = Vector(4, 5)

print(v1 + v2)  # 输出 Vector(6, 8)
print(v1 - v2)  # 输出 Vector(-2, -2)
print(v1 * 3)   # 输出 Vector(6, 9)
print(v1 == v2) # 输出 False

2、应用场景

2.1、增强代码的可读性

操作符重载可以让代码更具可读性。当你定义了一个自定义的类并且重载了操作符，你可以使用操作符的方式来进行类实例的操作，而不是调用方法。例如：

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

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

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # 使用重载的 "+" 操作符
print(v3)  # 输出 Vector(4, 6)

在这个例子中，+ 操作符被重载来实现 Vector 对象的相加，使得代码更清晰易懂。

2.2、 实现类的数学运算

如果你创建了一个表示数学对象（如向量、矩阵、复数等）的类，操作符重载可以让这些对象支持标准的数学运算。例如，重载 * 操作符来实现矩阵的乘法：

class Matrix:
    def __init__(self, data):
        self.data = data

    def __mul__(self, other):
        result = [[0, 0], [0, 0]]
        for i in range(2):
            for j in range(2):
                result[i][j] = sum(self.data[i][k] * other.data[k][j] for k in range(2))
        return Matrix(result)

    def __repr__(self):
        return f"Matrix({self.data})"

m1 = Matrix([[1, 2], [3, 4]])
m2 = Matrix([[5, 6], [7, 8]])
m3 = m1 * m2  # 使用重载的 "*" 操作符
print(m3)  # 输出 Matrix([[19, 22], [43, 50]])

2.3、支持自定义的数据结构

操作符重载可以让你为自定义的数据结构实现特定的行为。例如，如果你实现了一个自定义的容器类（如栈或队列），你可以重载操作符来支持标准的集合操作：

class Stack:
    def __init__(self):
        self.items = []

    def __add__(self, other):
        new_stack = Stack()
        new_stack.items = self.items + other.items
        return new_stack

    def __repr__(self):
        return f"Stack({self.items})"

s1 = Stack()
s1.items = [1, 2, 3]
s2 = Stack()
s2.items = [4, 5, 6]
s3 = s1 + s2  # 使用重载的 "+" 操作符
print(s3)  # 输出 Stack([1, 2, 3, 4, 5, 6])

2.4、简化 API 设计

操作符重载可以帮助简化 API 设计，使得用户与类的交互更加直观。例如，通过重载比较操作符 (==, <, >)，你可以使类实例之间的比较变得自然：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __lt__(self, other):
        return self.age < other.age

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
print(p1 < p2)  # 输出 False，因为 30 不小于 25

2.5、实现链式操作和流式接口

操作符重载使得链式操作成为可能。这种编程风格允许你将多个操作连在一起，使代码更加简洁和易于理解。例如，重载 | 操作符来支持管道操作。

class Step:
    def __or__(self, other):
        return ChainedOperation(self, other)

class ChainedOperation:
    def __init__(self, first, second):
        self.first = first
        self.second = second

    def invoke(self, data):
        intermediate_result = self.first.process(data)
        return self.second.parse(intermediate_result)

class StepA(Step):
    def process(self, data):
        return data + " processed by StepA"

class StepB(Step):
    def parse(self, data):
        return data + " and then by StepB"

chain = StepA() | StepB()
result = chain.invoke("Initial data")
print(result)  # 输出: Initial data processed by StepA and then by StepB

3、总结

操作符重载在 Python 中可以提升代码的表达力和可读性，使得自定义对象能够以自然的方式参与运算。它允许开发者定义和控制自定义对象的行为，使其更加符合数学、逻辑或业务需求。然而，使用操作符重载时需要谨慎，以确保重载的行为符合操作符的直观意义，避免产生混淆。