在Python中，單下劃線“_”和雙下劃線“__”的使用場景和含義有顯著區別，主要體現在命名約定和語法

一、單下劃線“_”的使用場景

單下劃線更多是編程約定（而非強制語法），用于傳遞特定的“暗示”，不影響代碼的實際運行。

1. 作為臨時變量/占位符

用于表示“臨時”或“無關緊要”的變量，僅作為語法占位，無需實際使用。
示例：

# 循環中不需要用到的變量
for _ in range(5):print("Hello")# 解包時忽略某些值（只關心第二個和第四個元素）
data = (10, 20, 30, 40)
_, b, _, d = data  # 用_忽略10和30
print(b, d)  # 輸出：20 40

2. 表示“內部使用”的變量/函數（模塊/類級別）

按約定，單下劃線開頭的變量、函數或類（如_x、_func()）表示“僅供內部使用”，不建議外部直接訪問（但Python不強制限制）。
示例：

# 模塊內的“內部”變量
# mymodule.py
_x = 100  # 暗示外部不要直接使用def _internal_func():  # 內部工具函數return "內部邏輯"def public_func():  # 公開接口return _internal_func()  # 內部調用# 外部導入時，默認不會導入單下劃線開頭的對象
from mymodule import *  # 不會導入_x和_internal_func

在類中，單下劃線開頭的屬性/方法也表示“內部使用”，提醒子類或外部不要隨意修改：

class MyClass:def __init__(self):self.public = "公開屬性"self._internal = "內部屬性（約定）"  # 外部仍可訪問，但不建議def _internal_method(self):  # 內部方法return "內部邏輯"def public_method(self):return self._internal_method()  # 內部調用

3. 交互式解釋器中的“上一次結果”

在Python交互式環境（如IDLE、Jupyter）中，_會自動保存上一次表達式的結果。
示例：

>>> 1 + 2
3
>>> _  # 引用上一次結果
3
>>> _ * 2
6
>>> _
6

4. 數字分隔符（Python 3.6+）

用于分割長數字，提高可讀性（不影響數值本身）。
示例：

large_num = 1_000_000  # 等價于1000000
print(large_num)  # 輸出：1000000pi = 3_1415_9265  # 更易讀的格式

二、雙下劃線“__”的使用場景

雙下劃線有明確的語法特性，不僅是約定，會影響Python的解析行為。

1. 名稱修飾（Name Mangling）：避免子類覆蓋父類成員

在類中，雙下劃線開頭的變量或方法（如__x）會被Python自動“修飾”（重命名），形式為_ClassName__x，防止子類意外覆蓋父類的成員。
原理：Python解釋器在編譯時會修改名稱，確保父類的私有成員在子類中不被沖突。
示例：

class Parent:def __init__(self):self.__secret = "父類的秘密"  # 雙下劃線開頭def __print_secret(self):  # 雙下劃線開頭的方法print(self.__secret)class Child(Parent):def __init__(self):super().__init__()self.__secret = "子類的秘密"  # 看似重名，實際不會沖突def __print_secret(self):  # 看似重寫，實際不會覆蓋父類方法print(self.__secret)# 測試
p = Parent()
c = Child()# 直接訪問會報錯（因為名稱已被修飾）
# print(p.__secret)  # AttributeError# 查看修飾后的名稱
print(p._Parent__secret)  # 輸出：父類的秘密（正確訪問方式）
print(c._Child__secret)   # 輸出：子類的秘密（正確訪問方式）p._Parent__print_secret()  # 輸出：父類的秘密
c._Child__print_secret()   # 輸出：子類的秘密

注意：名稱修飾的目的不是“禁止訪問”，而是“避免意外覆蓋”。通過_ClassName__member仍可訪問（不建議）。

2. 雙下劃線開頭和結尾：魔術方法（Magic Methods）

格式為__xxx__的方法是Python的“魔術方法”（或“特殊方法”），由Python內置定義，用于實現類的特殊行為（如構造、比較、運算等）。
特點：

• 由Python自動調用（如__init__在創建對象時調用），無需手動調用。
• 用戶不應自定義類似格式的方法（避免與內置功能沖突）。

示例：

class MyClass:def __init__(self, value):  # 構造方法，創建對象時調用self.value = valuedef __str__(self):  # 定義print()時的輸出格式return f"MyClass(value={self.value})"def __add__(self, other):  # 定義+運算符的行為return MyClass(self.value + other.value)obj1 = MyClass(10)
obj2 = MyClass(20)
print(obj1)  # 自動調用__str__()，輸出：MyClass(value=10)
print(obj1 + obj2)  # 自動調用__add__()，輸出：MyClass(value=30)

三、魔術方法（Magic Methods，又稱特殊方法，格式為__xxx__）

前面我們提到魔術方法（Magic Methods，又稱特殊方法，格式為__xxx__），這里我們詳細討論一下。
魔術方法是Python中預定義的特殊函數，用于讓自定義類實現與Python內置語法、函數或運算符的交互能力。它們的核心作用是“讓自定義對象像內置對象（如列表、字典、整數）一樣自然地融入Python生態”，大幅提升代碼的可讀性和易用性。

1、對象的創建與生命周期管理

用于控制對象的創建、初始化、銷毀等過程，是最基礎的魔術方法。

魔術方法	作用	應用場景舉例
__new__(cls)	實例創建的第一步（分配內存），返回實例	實現單例模式（確保類只有一個實例）
__init__(self)	實例初始化（設置初始屬性）	所有類的基礎初始化（必用）
__del__(self)	實例被銷毀時調用（垃圾回收）	釋放資源（如關閉文件、數據庫連接）

示例：單例模式（__new__）
確保一個類只有一個實例（如配置管理器、日志管理器）：

class Singleton:_instance = None  # 存儲唯一實例def __new__(cls):if cls._instance is None:cls._instance = super().__new__(cls)  # 首次創建實例return cls._instance  # 后續調用直接返回已有實例# 測試：無論創建多少次，都是同一個實例
a = Singleton()
b = Singleton()
print(a is b)  # 輸出：True

2、字符串表示與格式化

用于定義對象轉換為字符串的規則，影響print()、str()、repr()等函數的輸出，便于調試和用戶交互。

魔術方法	作用	區別
__str__(self)	返回“用戶友好”的字符串表示	被str(obj)、print(obj)調用
__repr__(self)	返回“開發者友好”的字符串表示（可重現對象）	被repr(obj)、控制臺直接輸出調用

示例：自定義日志對象的字符串表示

class Log:def __init__(self, level, message):self.level = levelself.message = messagedef __str__(self):# 用戶看到的簡潔信息return f"[{self.level.upper()}] {self.message}"def __repr__(self):# 開發者看到的詳細信息（可用于重建對象）return f"Log(level='{self.level}', message='{self.message}')"log = Log("error", "文件不存在")
print(log)  # 調用__str__：[ERROR] 文件不存在
print(repr(log))  # 調用__repr__：Log(level='error', message='文件不存在')

3、運算符重載

讓自定義對象支持Python的內置運算符（如+、==、>等），使代碼更直觀。

魔術方法	對應運算符/操作	應用場景
__add__(self, other)	self + other	自定義加法（如向量相加、字符串拼接）
__sub__(self, other)	self - other	自定義減法
__eq__(self, other)	self == other	自定義相等性判斷
__lt__(self, other)	self < other	自定義小于比較（支持排序）
__len__(self)	len(self)	支持長度計算（如容器類）

示例：實現向量加法與比較

class Vector:def __init__(self, x, y):self.x = xself.y = y# 支持向量加法：v1 + v2def __add__(self, other):return Vector(self.x + other.x, self.y + other.y)# 支持相等判斷：v1 == v2def __eq__(self, other):return self.x == other.x and self.y == other.y# 支持小于判斷（按模長）：v1 < v2def __lt__(self, other):return (self.x**2 + self.y**2) < (other.x**2 + other.y**2)def __str__(self):return f"Vector({self.x}, {self.y})"v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # 調用__add__：Vector(4, 6)
print(v1 == v2)  # 調用__eq__：False
print(v1 < v2)   # 調用__lt__：True（v1模長√5 < v2模長√25）

4、容器行為模擬

讓自定義類像內置容器（列表、字典、集合）一樣支持索引、切片、迭代、in判斷等操作。

魔術方法	對應操作	應用場景
__getitem__(self, key)	obj[key]（獲取元素）	支持索引/切片訪問（如自定義列表）
__setitem__(self, key, value)	obj[key] = value（設置元素）	支持賦值操作
__contains__(self, item)	item in obj（成員判斷）	支持in運算符
__iter__(self)	迭代（for item in obj）	讓對象可迭代
__len__(self)	len(obj)（長度）	支持長度計算

示例：實現一個簡易的自定義列表

class MyList:def __init__(self, data):self.data = list(data)# 支持索引訪問：obj[i]def __getitem__(self, key):return self.data[key]# 支持賦值：obj[i] = valuedef __setitem__(self, key, value):self.data[key] = value# 支持in判斷：item in objdef __contains__(self, item):return item in self.data# 支持迭代：for item in objdef __iter__(self):return iter(self.data)  # 委托給內置列表的迭代器# 支持len()：len(obj)def __len__(self):return len(self.data)ml = MyList([1, 2, 3, 4])
print(ml[1])  # 調用__getitem__：2
ml[2] = 100   # 調用__setitem__
print(3 in ml)  # 調用__contains__：False（已被改為100）
for item in ml:  # 調用__iter__print(item, end=" ")  # 輸出：1 2 100 4

5、上下文管理（with語句）

通過__enter__和__exit__實現“資源自動獲取與釋放”，無需手動處理關閉（如文件、數據庫連接）。

魔術方法	作用
__enter__(self)	進入with塊時調用，返回資源對象
__exit__(self, exc_type, exc_val, exc_tb)	退出with塊時調用，釋放資源（無論是否出錯）

示例：自定義文件管理器（自動關閉文件）

class FileManager:def __init__(self, filename, mode):self.filename = filenameself.mode = modeself.file = Nonedef __enter__(self):self.file = open(self.filename, self.mode)  # 獲取資源return self.file  # 允許with ... as f使用def __exit__(self, exc_type, exc_val, exc_tb):self.file.close()  # 釋放資源（必執行）# 可處理異常（如返回True表示已處理異常）return False# 使用with語句：自動調用__enter__和__exit__
with FileManager("test.txt", "w") as f:f.write("Hello, Magic Methods!")
# 退出with塊后，文件已自動關閉，無需手動f.close()

6、屬性訪問控制

用于攔截或定制對象的屬性訪問（獲取、設置、刪除），實現動態屬性、權限控制等。

魔術方法	作用	應用場景
__getattr__(self, name)	訪問不存在的屬性時調用	動態生成屬性（如從字典映射）
__setattr__(self, name, value)	設置屬性時調用（包括存在的）	限制屬性修改（如只讀屬性）
__delattr__(self, name)	刪除屬性時調用	禁止刪除關鍵屬性

示例：動態映射屬性到內部字典

class DynamicAttr:def __init__(self):self.data = {"name": "默認名稱", "age": 0}  # 內部存儲# 訪問屬性時，從data中獲取（如obj.name → data["name"]）def __getattr__(self, name):if name in self.data:return self.data[name]raise AttributeError(f"屬性'{name}'不存在")# 設置屬性時，存入data（如obj.age = 18 → data["age"] = 18）def __setattr__(self, name, value):if name == "data":  # 特殊處理內部的data屬性super().__setattr__(name, value)else:self.data[name] = value  # 其他屬性存入dataobj = DynamicAttr()
print(obj.name)  # 調用__getattr__：默認名稱
obj.age = 20     # 調用__setattr__
print(obj.age)   # 輸出：20
obj.gender = "男"  # 動態添加新屬性
print(obj.gender)  # 輸出：男

7、可調用對象

通過__call__方法讓類的實例像函數一樣被調用，實現“帶狀態的函數”。

示例：帶計數器的函數

class Counter:def __init__(self):self.count = 0  # 維護狀態# 實例被調用時執行（如obj()）def __call__(self):self.count += 1return f"已調用{self.count}次"counter = Counter()
print(counter())  # 調用__call__：已調用1次
print(counter())  # 輸出：已調用2次
print(counter.count)  # 查看狀態：2

魔術方法的核心價值是讓自定義類“適配”Python的內置語法和功能，使代碼更符合Python的“風格”（簡潔、直觀）。

合理使用魔術方法能大幅提升自定義類的靈活性和易用性，但避免過度使用（如自定義的__xxx__可能與內置功能沖突）。

四、回顧

類型	本質	作用場景	語法強制力
單下劃線_	編程約定	臨時變量、內部成員（提示）、數字分隔符、交互式解釋器結果	無（僅約定）
雙下劃線__	語法特性	名稱修飾（避免子類覆蓋）、魔術方法（__xxx__，內置行為）	有（解釋器處理）

使用建議

1. 單下劃線：遵循“內部成員”約定，提醒自己和他人不要隨意外部訪問，但不阻止訪問。
2. 雙下劃線：僅在需要“防止子類覆蓋父類關鍵成員”時使用，避免過度使用（會降低代碼可讀性）。
3. 魔術方法：僅使用Python內置的__xxx__方法，不自定義類似格式的方法（如__myfunc__）。