從入門到精通的Python魔術方法(Magic Methods)完全指南
更新時間：2025年07月17日 08:38:41 作者：盛夏綻放
這篇文章主要詳細介紹了Python中特殊的魔術方法,用于實現(xiàn)各種內置操作,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
本文全面介紹了Python中特殊的魔術方法，這些以雙下劃線開頭和結尾的方法（如__init__）為類提供了"魔法"般的行為。主要內容包括：
基礎知識：魔術方法由Python自動調用，用于實現(xiàn)各種內置操作，如對象初始化(init)、字符串表示(str, repr)等。
核心分類：
- 對象生命周期方法(new, del)
- 比較運算符(eq, __lt__等)
- 算術運算(add, __mul__等)
- 容器模擬(len, __getitem__等)
實際應用：通過豐富的代碼示例展示了如何利用魔術方法實現(xiàn)自定義類的高級行為，如向量運算、購物車容器等。
魔術方法使Python的面向對象編程更加強大和靈活，是構建專業(yè)級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. 魔術方法的特點
- 命名規(guī)則：雙下劃線開頭和結尾，如
__method__ - 自動調用：由Python解釋器在特定情況下調用
- 豐富功能：實現(xiàn)運算符重載、對象生命周期控制等
- 性能優(yōu)化：比普通方法調用更快（直接由解釋器處理）
二、常用魔術方法分類詳解
1. 對象創(chuàng)建與初始化
| 方法 | 調用時機 | 典型用途 |
|---|---|---|
| __new__ | 創(chuàng)建實例時 | 控制實例創(chuàng)建過程（單例模式等） |
| __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. 對象表示與字符串轉換
| 方法 | 調用時機 | 區(qū)別 |
|---|---|---|
| __str__ | str(obj), print(obj) | 用戶友好的字符串表示 |
| __repr__ | repr(obj), 交互式環(huán)境 | 明確的、可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:
# 執(zhí)行一些操作
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 (實例像函數(shù)一樣調用)
三、高級魔術方法
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. 描述符協(xié)議
| 方法 | 調用時機 |
|---|---|
| __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. 數(shù)值類型轉換
| 方法 | 調用時機 |
|---|---|
| __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
四、魔術方法最佳實踐
謹慎使用：只在確實需要時實現(xiàn)魔術方法
保持一致性：
- 實現(xiàn)
__eq__時也應實現(xiàn)__hash__ - 實現(xiàn)比較運算符時最好實現(xiàn)全套
性能考慮：魔術方法會被頻繁調用，應保持高效
文檔說明：明確記錄每個魔術方法的行為
避免過度使用：不是所有類都需要成為"全能選手"
五、綜合案例：自定義分數(shù)類
class Fraction:
"""自定義分數(shù)類，演示多種魔術方法"""
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):
"""計算最大公約數(shù)"""
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):
"""轉換為浮點數(shù)"""
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__)
通過這個完整的分數(shù)類實現(xiàn)，我們綜合運用了多種魔術方法，使自定義類能夠像內置類型一樣自然地參與各種運算和操作。
魔術方法是Python強大而靈活的特性，合理使用它們可以讓你的類更加Pythonic，與Python語言的其他特性無縫集成。記住，能力越大責任越大，魔術方法應該用來增強代碼的清晰度和可用性，而不是制造"魔法"般的復雜性。
以上就是從入門到精通的Python魔術方法(Magic Methods)完全指南的詳細內容，更多關于Python魔術方法的資料請關注腳本之家其它相關文章！
相關文章
今天教各位小伙伴怎么用Python給二維碼圖片添加提示文字,文中有非常詳細的代碼示例,對正在學習python的小伙伴很有幫助,需要的朋友可以參考下2021-05-05
python使用numpy按一定格式讀取bin文件的實現(xiàn)
這篇文章主要介紹了python使用numpy按一定格式讀取bin文件的實現(xiàn)方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-05-05
python 的類中主要會使用的兩種變量:類變量與成員變量。類變量是類所有實例化對象共有的，而成員變量是每個實例化對象自身特有的。下面這篇文章主要給大家介紹了在python中類變量與成員變量的一些使用注意點，需要的朋友可以參考借鑒，下面來一起看看吧。2017-04-04
pandas dataframe rolling移動計算方式
在Pandas中,rolling()方法用于執(zhí)行移動窗口計算,常用于時間序列數(shù)據(jù)分析,例如,計算某商品的7天或1個月銷售總量,可以通過rolling()輕松實現(xiàn),該方法的關鍵參數(shù)包括window（窗口大?。?min_periods（最小計算周期）2024-09-09
Python3.5內置模塊之shelve模塊、xml模塊、configparser模塊、hashlib、hmac模塊用法
這篇文章主要介紹了Python3.5內置模塊之shelve模塊、xml模塊、configparser模塊、hashlib、hmac模塊,結合實例形式較為詳細的分析了shelve、xml、configparser、hashlib、hmac等模塊的功能及使用方法,需要的朋友可以參考下2019-04-04
這篇文章主要介紹了Python快速生成隨機密碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-08-08
Python中rapidjson參數(shù)校驗實現(xiàn)
通常需要對前端傳遞過來的參數(shù)進行校驗，校驗的方式有多種，本文主要介紹了Python中rapidjson參數(shù)校驗實現(xiàn)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-07-07
Python3.6通過自帶的urllib通過get或post方法請求url的實例
下面小編就為大家分享一篇Python3.6通過自帶的urllib通過get或post方法請求url的實例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-05-05
在文本分析和數(shù)據(jù)可視化的領域中,詞云是一種展示文本數(shù)據(jù)中關鍵詞頻率的直觀方式,Python作為一種強大的編程語言,提供了多種庫來幫助我們生成詞云,在本文中,我們將通過一個簡單的示例,展示如何使用Python生成中文詞云,需要的朋友可以參考下2024-07-07
這篇文章主要為大家詳細介紹了python實現(xiàn)用戶答題功能，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01