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