Python中的操作符重载与魔术方法实现

知识点描述
操作符重载是Python中通过实现特定的魔术方法（magic methods）来赋予自定义类与内置类型相似行为的能力。这些方法以双下划线开头和结尾（如__add__），允许我们定义对象在遇到操作符（如+、-、*）时的行为。掌握操作符重载可以让自定义类更直观易用。

详细讲解

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

• 本质：通过实现特殊方法让自定义类支持Python内置操作
• 优势：使对象操作更符合直觉，代码更简洁易读
• 示例：a + b 实际调用 a.__add__(b)

2. 算术运算符重载

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # 实现加法运算
    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented
    
    # 实现字符串表示
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 使用示例
v1 = Vector(1, 2)
v2 = Vector(3, 4)
result = v1 + v2  # 调用 v1.__add__(v2)
print(result)  # Vector(4, 6)

3. 反向运算符和就地运算符

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # 正向加法
    def __add__(self, other):
        if isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        return NotImplemented
    
    # 反向加法（当左操作数不支持时调用）
    def __radd__(self, other):
        return self.__add__(other)
    
    # 就地加法（+=）
    def __iadd__(self, other):
        if isinstance(other, (int, float)):
            self.x += other
            self.y += other
            return self  # 必须返回self
        return NotImplemented

v = Vector(1, 2)
v += 5  # 调用 __iadd__
print(v)  # Vector(6, 7)

4. 比较运算符重载

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = 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.x**2 + self.y**2) < (other.x**2 + other.y**2)
        return NotImplemented
    
    # 其他比较运算符会自动生成
    # __ne__ 由 __eq__ 自动生成
    # __gt__ 由 __lt__ 自动生成
    # __le__ 和 __ge__ 需要单独实现

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 == v2)  # False
print(v1 < v2)   # True

5. 类型转换运算符

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __bool__(self):
        """定义对象的真值测试"""
        return self.x != 0 or self.y != 0
    
    def __int__(self):
        """int(vector) 的行为"""
        return int((self.x**2 + self.y**2)**0.5)
    
    def __float__(self):
        """float(vector) 的行为"""
        return (self.x**2 + self.y**2)**0.5

v = Vector(3, 4)
print(bool(v))   # True
print(int(v))    # 5
print(float(v))  # 5.0

6. 容器类操作符重载

class CustomList:
    def __init__(self, items):
        self._items = list(items)
    
    def __getitem__(self, index):
        """支持索引访问"""
        return self._items[index]
    
    def __setitem__(self, index, value):
        """支持索引赋值"""
        self._items[index] = value
    
    def __len__(self):
        """支持len()函数"""
        return len(self._items)
    
    def __contains__(self, item):
        """支持in操作符"""
        return item in self._items
    
    def __iter__(self):
        """支持迭代"""
        return iter(self._items)

cl = CustomList([1, 2, 3])
print(cl[1])        # 2
print(len(cl))      # 3
print(2 in cl)      # True

7. 调用运算符重载

class CallableClass:
    def __init__(self, name):
        self.name = name
    
    def __call__(self, *args, **kwargs):
        """使实例可像函数一样调用"""
        print(f"{self.name}被调用，参数：{args}, {kwargs}")

func = CallableClass("我的可调用类")
func(1, 2, key="value")  # 我的可调用类被调用，参数：(1, 2), {'key': 'value'}

8. 最佳实践和注意事项

• 保持一致性：重载的操作符行为应该符合直觉
• 返回NotImplemented：当操作不支持时，返回NotImplemented而不是抛出异常
• 避免过度使用：只在确实能提高代码可读性时使用
• 考虑性能：操作符重载可能影响性能，特别是在频繁调用的场景

完整示例：实现一个完整的数学向量类

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented
    
    def __sub__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x - other.x, self.y - other.y)
        return NotImplemented
    
    def __mul__(self, scalar):
        if isinstance(other, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented
    
    def __eq__(self, other):
        if isinstance(other, Vector):
            return self.x == other.x and self.y == other.y
        return False
    
    def __abs__(self):
        return (self.x**2 + self.y**2)**0.5
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 使用示例
v1 = Vector(2, 3)
v2 = Vector(1, 1)
print(v1 + v2)  # Vector(3, 4)
print(v1 - v2)  # Vector(1, 2)
print(abs(v1))  # 3.605551275463989