本文全面介绍了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语言的其他特性无缝集成。记住，能力越大责任越大，魔术方法应该用来增强代码的清晰度和可用性，而不是制造"魔法"般的复杂性。
以上就是从入门到精通的python魔术方法(magic methods)完全指南的详细内容，更多关于python魔术方法的资料请关注代码网其它相关文章！