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

admin • • Python学习

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

 作者：盛夏绽放
这篇文章主要详细介绍了Python中特殊的魔术方法,用于实现各种内置操作,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下。

本文全面介绍了Python中特殊的魔术方法，这些以双下划线开头和结尾的方法（如__init__）为类提供了"魔法"般的行为。主要内容包括：

基础知识：魔术方法由Python自动调用，用于实现各种内置操作，如对象初始化(init)、字符串表示(str,repr)等。

核心分类：

  • 对象生命周期方法(new,del)
  • 比较运算符(eq, __lt__等)
  • 算术运算(add, __mul__等)
  • 容器模拟(len, __getitem__等)

实际应用：通过丰富的代码示例展示了如何利用魔术方法实现自定义类的高级行为，如向量运算、购物车容器等。

魔术方法使Python的面向对象编程更加强大和灵活，是构建专业级Python类的关键工具。

魔术方法(Magic Methods)是Python面向对象编程中的特殊方法，它们赋予类"魔法"般的行为。本文将全面解析Python中的魔术方法，通过丰富的示例和实际应用场景，带你深入理解这一重要概念。

一、魔术方法基础

1. 什么是魔术方法

魔术方法是以双下划线开头和结尾的特殊方法（如__init__），Python会在特定时机自动调用它们。它们不是用来直接调用的，而是让类能够支持Python的各种内置操作。

1
2
3
4
5
6
7
8
9
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__ 对象销毁时 清理资源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 自定义格式化输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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__ >=
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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__
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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__ 迭代对象时
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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块时
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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()形式调用时
1
2
3
4
5
6
7
8
9
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__ 删除属性时
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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__ 删除描述符值时
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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__
  • 实现比较运算符时最好实现全套

性能考虑：魔术方法会被频繁调用，应保持高效

文档说明：明确记录每个魔术方法的行为

避免过度使用：不是所有类都需要成为"全能选手"

五、综合案例：自定义分数类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
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)完全指南的详细内容。

 

 

 

学习资料见知识星球。

以上就是今天要分享的技巧，你学会了吗？若有什么问题，欢迎在下方留言。

快来试试吧，小琥 my21ke007。获取 1000个免费 Excel模板福利​​​​！

更多技巧， www.excelbook.cn

欢迎 加入 零售创新 知识星球，知识星球主要以数据分析、报告分享、数据工具讨论为主；

Excelbook.cn Excel技巧 SQL技巧 Python 学习！

你将获得：

1、价值上万元的专业的PPT报告模板。

2、专业案例分析和解读笔记。

3、实用的Excel、Word、PPT技巧。

4、VIP讨论群，共享资源。

5、优惠的会员商品。

6、一次付费只需129元，即可下载本站文章涉及的文件和软件。

文章版权声明 1、本网站名称：Excelbook
2、本站永久网址：http://www.excelbook.cn
3、本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长王小琥进行删除处理。
4、本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报。
6、本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END
分享
二维码
< <上一篇
下一篇>>