文章目录
Python类中魔术方法(Magic Methods)完全指南：从入门到精通一、魔术方法基础1. 什么是魔术方法？2. 魔术方法的特点
二、常用魔术方法分类详解1. 对象创建与初始化2. 对象表示与字符串转换3. 比较运算符重载4. 算术运算符重载5. 容器类型模拟6. 上下文管理器7. 可调用对象
三、高级魔术方法1. 属性访问控制2. 描述符协议3. 数值类型转换
四、魔术方法最佳实践五、综合案例：自定义分数类
Python类中魔术方法(Magic Methods)完全指南：从入门到精通
本文全面介绍了Python中特殊的魔术方法，这些以双下划线开头和结尾的方法（如__init__）为类提供了"魔法"般的行为。主要内容包括： 基础知识：魔术方法由Python自动调用，用于实现各种内置操作，如对象初始化(init)、字符串表示(str, repr)等。 核心分类： 对象生命周期方法(new, del) 比较运算符(eq, __lt__等) 算术运算(add, __mul__等) 容器模拟(len, __getitem__等) 实际应用：通过丰富的代码示例展示了如何利用魔术方法实现自定义类的高级行为，如向量运算、购物车容器等。 魔术方法使Python的面向对象编程更加强大和灵活，是构建专业级Python类的关键工具。
魔术方法(Magic Methods)是Python面向对象编程中的特殊方法，它们赋予类"魔法"般的行为。本文将全面解析Python中的魔术方法，通过丰富的示例和实际应用场景，带你深入理解这一重要概念。
一、魔术方法基础
1. 什么是魔术方法？
魔术方法是以双下划线开头和结尾的特殊方法（如__init__），Python会在特定时机自动调用它们。它们不是用来直接调用的，而是让类能够支持Python的各种内置操作。
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"
2. 魔术方法的特点
命名规则：双下划线开头和结尾，如__method__自动调用：由Python解释器在特定情况下调用丰富功能：实现运算符重载、对象生命周期控制等性能优化：比普通方法调用更快（直接由解释器处理）
二、常用魔术方法分类详解
1. 对象创建与初始化
方法调用时机典型用途__new__创建实例时控制实例创建过程（单例模式等）__init__初始化实例时设置初始属性__del__对象销毁时清理资源
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
2. 对象表示与字符串转换
方法调用时机区别__str__str(obj), print(obj)用户友好的字符串表示__repr__repr(obj), 交互式环境明确的、可eval的表示__format__format(obj), f-string自定义格式化输出
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
3. 比较运算符重载
方法对应运算符__lt__<__le__<=__eq__==__ne__!=__gt__>__ge__>=
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
4. 算术运算符重载
方法对应运算符反向方法__add__+__radd____sub__-__rsub____mul__*__rmul____truediv__/__rtruediv____floordiv__//__rfloordiv____mod__%__rmod____pow__**__rpow__
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__)
5. 容器类型模拟
方法用途__len__len(obj)__getitem__obj[key]__setitem__obj[key] = value__delitem__del obj[key]__contains__item in obj__iter__迭代对象时
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)
6. 上下文管理器
方法调用时机__enter__进入with块时__exit__退出with块时
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秒
7. 可调用对象
方法调用时机__call__obj()形式调用时
class Adder:
def __init__(self, n):
self.n = n
def __call__(self, x):
return self.n + x
add5 = Adder(5)
print(add5(3)) # 8 (实例像函数一样调用)
三、高级魔术方法
1. 属性访问控制
方法调用时机__getattr__访问不存在的属性时__getattribute__访问任何属性时__setattr__设置属性时__delattr__删除属性时
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
2. 描述符协议
方法调用时机__get__获取描述符值时__set__设置描述符值时__delete__删除描述符值时
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 # 报错
3. 数值类型转换
方法调用时机__int__int(obj)__float__float(obj)__bool__bool(obj)__complex__complex(obj)
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
四、魔术方法最佳实践
谨慎使用：只在确实需要时实现魔术方法保持一致性：
实现__eq__时也应实现__hash__实现比较运算符时最好实现全套 性能考虑：魔术方法会被频繁调用，应保持高效文档说明：明确记录每个魔术方法的行为避免过度使用：不是所有类都需要成为"全能选手"
五、综合案例：自定义分数类
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__)
通过这个完整的分数类实现，我们综合运用了多种魔术方法，使自定义类能够像内置类型一样自然地参与各种运算和操作。
魔术方法是Python强大而灵活的特性，合理使用它们可以让你的类更加Pythonic，与Python语言的其他特性无缝集成。记住，能力越大责任越大，魔术方法应该用来增强代码的清晰度和可用性，而不是制造"魔法"般的复杂性。