从入门到精通的Python魔术方法(Magic Methods)完全指南

class MyClass:
    def __init__(self, value):
        self.value = value
    
    def __str__(self):
        return f"MyClass with value: {self.value}"

obj = MyClass(42)
print(obj)  # 自动调用__str__: "MyClass with value: 42"

class Resource:
    def __new__(cls, *args, **kwargs):
        print("__new__ called - creating instance")
        instance = super().__new__(cls)
        return instance
    
    def __init__(self, name):
        print("__init__ called - initializing")
        self.name = name
    
    def __del__(self):
        print(f"__del__ called - cleaning up {self.name}")

res = Resource("File")  # 输出: __new__ called → __init__ called
del res                 # 输出: __del__ called

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
    
    def __format__(self, format_spec):
        if format_spec == 'r':
            return f"{self.x}×{self.y}"
        return str(self)

p = Point(3, 4)
print(str(p))      # (3, 4)
print(repr(p))     # Point(3, 4)
print(f"{p}")      # (3, 4)
print(f"{p:r}")    # 3×4

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __eq__(self, other):
        return self.score == other.score
    
    def __lt__(self, other):
        return self.score < other.score
    
    def __le__(self, other):
        return self.score <= other.score

alice = Student("Alice", 85)
bob = Student("Bob", 90)
print(alice < bob)   # True
print(alice == bob)  # False

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 __mul__(self, scalar):
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented
    
    def __rmul__(self, scalar):
        return self.__mul__(scalar)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(5, 7)
print(v1 + v2)  # Vector(7, 10)
print(v1 * 3)   # Vector(6, 9)
print(2 * v1)   # Vector(4, 6) (调用__rmul__)

class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def __len__(self):
        return len(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, index, value):
        self.items[index] = value
    
    def __delitem__(self, index):
        del self.items[index]
    
    def __contains__(self, item):
        return item in self.items
    
    def __iter__(self):
        return iter(self.items)
    
    def add(self, item):
        self.items.append(item)

cart = ShoppingCart()
cart.add("苹果")
cart.add("香蕉")
cart.add("橙子")

print(len(cart))        # 3
print(cart[1])          # 香蕉
print("苹果" in cart)   # True

for item in cart:       # 迭代
    print(item)

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        self.end = time.time()
        print(f"耗时: {self.end - self.start:.2f}秒")
    
    def elapsed(self):
        return self.end - self.start

with Timer() as t:
    # 执行一些操作
    sum(range(1000000))

# 自动输出: 耗时: x.xx秒

class Adder:
    def __init__(self, n):
        self.n = n
    
    def __call__(self, x):
        return self.n + x

add5 = Adder(5)
print(add5(3))  # 8 (实例像函数一样调用)

class AttributeLogger:
    def __init__(self):
        self.data = {}
    
    def __getattr__(self, name):
        print(f"访问不存在的属性: {name}")
        return None
    
    def __setattr__(self, name, value):
        print(f"设置属性: {name} = {value}")
        super().__setattr__(name, value)
    
    def __delattr__(self, name):
        print(f"删除属性: {name}")
        super().__delattr__(name)

obj = AttributeLogger()
obj.x = 10      # 设置属性: x = 10
print(obj.x)    # 10
print(obj.y)    # 访问不存在的属性: y → None
del obj.x       # 删除属性: x

class Celsius:
    def __get__(self, instance, owner):
        return instance._celsius
    
    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度")
        instance._celsius = value

class Temperature:
    celsius = Celsius()  # 描述符
    
    def __init__(self, celsius):
        self.celsius = celsius  # 通过描述符赋值

temp = Temperature(25)
print(temp.celsius)  # 25
temp.celsius = 30    # 通过描述符修改
# temp.celsius = -300 # 报错

class Percentage:
    def __init__(self, value):
        self.value = value
    
    def __int__(self):
        return int(self.value)
    
    def __float__(self):
        return float(self.value / 100)
    
    def __bool__(self):
        return self.value != 0
    
    def __str__(self):
        return f"{self.value}%"

p = Percentage(75)
print(int(p))      # 75
print(float(p))    # 0.75
print(bool(p))     # True
print(bool(Percentage(0)))  # False

class Fraction:
    """自定义分数类，演示多种魔术方法"""
    
    def __init__(self, numerator, denominator=1):
        if denominator == 0:
            raise ValueError("分母不能为零")
        
        # 约分
        common = self.gcd(numerator, denominator)
        self.num = numerator // common
        self.den = denominator // common
    
    @staticmethod
    def gcd(a, b):
        """计算最大公约数"""
        while b:
            a, b = b, a % b
        return a
    
    def __add__(self, other):
        """重载+运算符"""
        if isinstance(other, int):
            other = Fraction(other)
        new_num = self.num * other.den + other.num * self.den
        new_den = self.den * other.den
        return Fraction(new_num, new_den)
    
    __radd__ = __add__  # 反向加法
    
    def __sub__(self, other):
        """重载-运算符"""
        return self.__add__(-other)
    
    def __neg__(self):
        """重载负号"""
        return Fraction(-self.num, self.den)
    
    def __mul__(self, other):
        """重载*运算符"""
        if isinstance(other, int):
            other = Fraction(other)
        return Fraction(self.num * other.num, self.den * other.den)
    
    __rmul__ = __mul__  # 反向乘法
    
    def __truediv__(self, other):
        """重载/运算符"""
        if isinstance(other, int):
            other = Fraction(other)
        return Fraction(self.num * other.den, self.den * other.num)
    
    def __eq__(self, other):
        """重载==运算符"""
        if isinstance(other, int):
            other = Fraction(other)
        return self.num == other.num and self.den == other.den
    
    def __lt__(self, other):
        """重载<运算符"""
        return self.num * other.den < other.num * self.den
    
    def __le__(self, other):
        """重载<=运算符"""
        return self.__lt__(other) or self.__eq__(other)
    
    def __str__(self):
        """字符串表示"""
        if self.den == 1:
            return str(self.num)
        return f"{self.num}/{self.den}"
    
    def __repr__(self):
        """解释器表示"""
        return f"Fraction({self.num}, {self.den})"
    
    def __float__(self):
        """转换为浮点数"""
        return self.num / self.den

# 使用示例
f1 = Fraction(3, 4)
f2 = Fraction(2, 5)

print(f1 + f2)    # 23/20
print(f1 - f2)    # 7/20
print(f1 * f2)    # 3/10
print(f1 / f2)    # 15/8
print(f1 == Fraction(6, 8))  # True
print(f1 < f2)    # False
print(float(f1))  # 0.75
print(2 + f1)     # 11/4 (调用__radd__)