Python 的 ast 模組提供強大的程式碼分析和轉換能力，允許開發者在執行時期修改程式碼邏輯。然而，動態執行程式碼存在安全風險，例如惡意程式碼注入和資源耗盡。本文將探討如何安全地使用 ast 模組進行動態程式碼執行，並介紹如何利用 AST 轉換進行效能最佳化。我們將探討執行時間限制、安全執行環境的建立，以及如何結合程式碼分析和轉換來提升程式碼品質。同時，我們也將探討如何使用 Descriptor 協定來精確控制類別屬性的存取行為，提升程式碼的可靠性和安全性。
實作安全的動態程式碼執行
最後，當設計系統需要動態轉換和執行程式碼時，需要考慮安全性和效能的互動作用。透過在轉換過程中加入 runtime 檢查，可以防止效能退化和安全漏洞。例如，可以在動態轉換的程式碼中加入執行時間或資源使用限制，以確保即使發生惡意 AST 修改，也不會耗盡系統資源。
以下是一個簡單的例子，示範如何使用 ast 和 exec 函式進行安全的動態程式碼執行：
import ast
import time
def safe_exec(code, timeout=2):
start_time = time.time()
exec_globals = {}
try:
exec(code, exec_globals)
except Exception as e:
print(f"Error: {e}")
finally:
end_time = time.time()
if end_time - start_time > timeout:
print("Timeout!")
內容解密：
在上述例子中，我們定義了一個 safe_exec 函式，該函式接受一段程式碼和一個可選的 timeout 引數。它使用 exec 函式執行程式碼，並在一個 dictionary 中捕捉任何異常。如果執行時間超過指定的 timeout，就會印出一個 timeout 訊息。
圖表翻譯：
flowchart TD
A[開始] --> B[定義 safe_exec 函式]
B --> C[接受程式碼和 timeout 引數]
C --> D[使用 exec 函式執行程式碼]
D --> E[捕捉異常]
E --> F[檢查 timeout]
F --> G[印出 timeout 訊息]
在這個流程圖中，我們展示了 safe_exec 函式的執行流程。從定義函式開始，到接受引數、執行程式碼、捕捉異常、檢查 timeout 和印出 timeout 訊息，每一步都清晰地展示了函式的邏輯。
執行時間限制與安全執行環境
在執行動態轉換的程式碼時，為了防止過度的計算時間，需要實施執行時間限制。以下範例展示瞭如何使用 Python 的time模組來限制執行時間：
import time
import ast
def safe_exec(code, timeout):
start_time = time.time()
try:
exec(code, {})
except Exception as e:
print(f"Error: {e}")
finally:
duration = time.time() - start_time
if duration > timeout:
raise TimeoutError("Execution exceeded allowed time limit.")
# 範例轉換程式碼執行
source_code = "for i in range(1000000): pass"
tree = ast.parse(source_code)
transformed_tree = CompositeTransformer().visit(tree)
ast.fix_missing_locations(transformed_tree)
compiled_code = compile(transformed_tree, filename="<ast>", mode="exec")
safe_exec(compiled_code, timeout=1)
這個範例示範瞭如何設定執行時間限制，以防止過度的計算時間。在生產系統中，還需要實施其他安全措施，例如記憶體使用限制和安全清理，以防止濫用或意外的錯誤行為。
AST 操作的安全性與效能
AST 操作是一種強大的工具，但也需要注意安全性和效能。為了確保安全性和效能，需要實施多重策略，包括：
- 嚴格的輸入驗證
- 受控的轉換過程
- 高效的遍歷和快取機制
- 安全的執行環境
- 持續的效能分析和測試
透過這些策略，開發人員可以利用 AST 操作的力量而不犧牲程式碼安全性或執行效率。
AST 操作的應用案例
AST 操作在各種實際場景中都有廣泛的應用，從靜態程式碼分析和自動重構到動態程式碼生成和元程式設計。以下討論了深入的案例研究和實際範例，以展示 AST 操作對於高階開發人員的實用性。
靜態程式碼分析
AST 操作的一個主要應用是靜態程式碼分析。透過 AST，開發人員可以提取大量的語義資訊，超越簡單的文字搜尋。例如，構建呼叫階層、偵測死程式碼或強制執行編碼標準都可以在 AST 提供的結構化表示上更可靠地執行。
一個常見的任務是識別未使用的變數。高階靜態分析器會遍歷指派和使用節點，構建符號表並跨作用域驗證變數參照。以下範例示範瞭如何構建符號表並標記未使用的變數：
import ast
from collections import defaultdict
class UnusedVariableAnalyzer(ast.NodeVisitor):
def __init__(self):
self.assignments = defaultdict(list)
self.usages = defaultdict(list)
def visit_FunctionDef(self, node):
# 處理函式引數作為指派
for arg in node.args.args:
self.assignments[arg.arg].append(('arg', node.lineno))
self.generic_visit(node)
def visit_Assign(self, node):
for target in node.targets:
if isinstance(target, ast.Name):
self.assignments[target.id].append(('assign', node.lineno))
self.generic_visit(node)
def visit_Name(self, node):
# 處理變數使用
self.usages[node.id].append(('use', node.lineno))
self.generic_visit(node)
這個範例展示瞭如何使用 AST 來分析程式碼並識別未使用的變數。透過這種方式，開發人員可以更好地理解程式碼結構和語義，從而提高程式碼品質和可維護性。
靜態分析和 AST 轉換的應用
靜態分析是一種在程式執行前對程式碼進行分析的技術，能夠幫助開發者找出程式碼中的問題和改進之處。Python 的ast模組提供了一種強大的方式來進行靜態分析和程式碼轉換。
未使用變數的分析
下面的例子展示瞭如何使用ast模組來分析未使用的變數：
import ast
class UnusedVariableAnalyzer(ast.NodeVisitor):
def __init__(self):
self.assignments = {}
self.usages = {}
def visit_Assign(self, node):
for target in node.targets:
if isinstance(target, ast.Name):
var = target.id
self.assignments.setdefault(var, []).append((node.ctx, node.lineno))
self.generic_visit(node)
def visit_Name(self, node):
if isinstance(node.ctx, ast.Load):
var = node.id
self.usages.setdefault(var, []).append(node.lineno)
self.generic_visit(node)
def report(self):
for var, assigns in self.assignments.items():
if var not in self.usages:
for context, lineno in assigns:
print(f"Variable '{var}' declared at line {lineno} is never used")
source_code = """
def compute(a, b):
result = a + b
temp = 42
return result
"""
tree = ast.parse(source_code)
analyzer = UnusedVariableAnalyzer()
analyzer.visit(tree)
analyzer.report()
這個例子構建了一個變數指定和使用的對映，並且報告那些沒有對應使用的變數。
程式碼轉換和元程式設計
AST 轉換也可以用於元程式設計，例如動態生成程式碼或在編譯時注入領域特定的建構。一個常見的元程式設計模式涉及修改 AST 來自動包裝函式以新增額外的行為。例如，可以在每個函式定義之前新增測試或日誌程式碼。
下面的程式碼片段實作了一個轉換器，該轉換器在每個函式定義之前新增測試程式碼以測量執行時間：
import ast
import time
class ProfilingInjector(ast.NodeTransformer):
def visit_FunctionDef(self, node):
self.generic_visit(node)
# Create instrumentation to record time before and after function execution
instrumentation = ast.parse("""
start_time = time.time()
try:
# function body
finally:
end_time = time.time()
print(f"Function {node.name} executed in {end_time - start_time:.2f} seconds")
""")
node.body = instrumentation.body + node.body
return node
這個轉換器修改了 AST 以新增測試程式碼，然後傳回修改過的 AST 節點。
內容解密：時間計算與記錄
在這個程式碼片段中，我們看到了一段使用 Python 的抽象語法樹（Abstract Syntax Tree, AST）來生成程式碼的過程。這段程式碼主要是用於計算某個程式碼區塊的執行時間，並將結果記錄下來。
首先，我們看到兩個指定陳述式：start_call和end_call。這兩個指定陳述式分別用於記錄程式碼執行的起始時間和結束時間。它們使用ast.Assign節點來表示指定操作，目標是分別將當前時間指定給__start_time和__end_time變數。
接下來，我們看到一個log_statement，它使用ast.Expr節點來表示一個表示式陳述式。在這個表示式中，我們使用ast.Call節點來呼叫print函式，並將計算出的執行時間作為其引數。執行時間的計算是透過從結束時間中減去起始時間來得出的。
值得注意的是，這段程式碼使用了抽象語法樹（AST）來動態生成程式碼。這種方法可以讓我們在執行時動態地生成和修改程式碼，對於某些特定的應用場景非常有用。
圖表翻譯：
graph LR
A[開始] --> B[記錄起始時間]
B --> C[執行程式碼]
C --> D[記錄結束時間]
D --> E[計算執行時間]
E --> F[記錄執行時間]
在這個 Mermaid 圖表中，我們視覺化了程式碼的執行流程。從開始到結束，程式碼會先記錄起始時間，然後執行指定的程式碼區塊，接著記錄結束時間，計算執行時間，最後記錄下執行時間。這個圖表幫助我們更好地理解程式碼的邏輯流程。
最佳化程式碼：在函式體內插入效能分析工具
背景介紹
在軟體開發中，瞭解程式碼的執行時間和效能是非常重要的。這可以幫助我們找出瓶頸並最佳化程式碼。Python 的 ast 模組提供了一種方式來分析和修改抽象語法樹（Abstract Syntax Tree, AST），從而實作程式碼的動態修改和最佳化。
解決方案
以下是使用 ast 模組來插入效能分析工具的示例程式碼：
import ast
import time
from ast import NodeTransformer
class ProfilingInjector(NodeTransformer):
def __init__(self):
self.start_call = ast.Expr(ast.Call(
func=ast.Name(id='start_profiling', ctx=ast.Load()),
args=[],
keywords=[]
))
self.end_call = ast.Expr(ast.Call(
func=ast.Name(id='end_profiling', ctx=ast.Load()),
args=[],
keywords=[]
))
self.log_statement = ast.Expr(ast.Call(
func=ast.Name(id='print', ctx=ast.Load()),
args=[ast.Str(s='Profiling completed')],
keywords=[]
))
def visit_FunctionDef(self, node):
new_body = [self.start_call] + node.body + [self.end_call, self.log_statement]
node.body = new_body
return node
# 範例程式碼
source_code = """
def heavy_computation(n):
total = 0
for i in range(n):
total += i ** 2
return total
"""
# 解析抽象語法樹
tree = ast.parse(source_code)
# 建立效能分析工具注入器
injector = ProfilingInjector()
# 修改抽象語法樹
transformed_tree = injector.visit(tree)
# 修復抽象語法樹中的位置資訊
ast.fix_missing_locations(transformed_tree)
# 編譯修改後的程式碼
compiled_code = compile(transformed_tree, filename="<ast>", mode="exec")
# 執行編譯後的程式碼
exec(compiled_code)
# 測試函式
def start_profiling():
global start_time
start_time = time.time()
def end_profiling():
global start_time
end_time = time.time()
print(f"Execution time: {end_time - start_time} seconds")
heavy_computation(1000000)
內容解密：
- 效能分析工具注入：我們定義了一個
ProfilingInjector類別，繼承自NodeTransformer。這個類別負責在函式體內插入效能分析工具。 - 抽象語法樹的修改：在
visit_FunctionDef方法中，我們修改了函式體內的節點。插入了start_profiling和end_profiling函式呼叫，以及一個 log 陳述式。 - 編譯和執行：我們編譯了修改後的抽象語法樹，並執行了編譯後的程式碼。
- 測試函式：我們定義了
start_profiling和end_profiling函式，分別用於記錄開始和結束時間，並計算執行時間。
圖表翻譯：
graph LR
A[原始程式碼] -->|解析|> B[抽象語法樹]
B -->|修改|> C[修改後的抽象語法樹]
C -->|編譯|> D[編譯後的程式碼]
D -->|執行|> E[執行結果]
E -->|計算執行時間|> F[輸出執行時間]
這個圖表展示了從原始程式碼到輸出執行時間的整個過程。
動態程式碼生成與抽象語法樹轉換
在軟體開發中，動態程式碼生成是一種強大的技術，允許我們根據執行時的輸入或條件生成程式碼。抽象語法樹（AST）轉換是一種實作此功能的方法，透過構建和操作 AST 來生成程式碼。
AST 轉換的優點
AST 轉換提供了一種安全可靠的方式來生成程式碼，避免了手動字串格式化的陷阱。透過構建 AST，我們可以確保生成的程式碼是語法正確的，並且可以被編譯器或解譯器正確解析。
動態程式碼生成的應用
動態程式碼生成的應用包括效能監控、自動除錯和自適應最佳化。透過在執行時生成程式碼，我們可以根據具體的情況最佳化程式的行為，提高效率和可靠性。
示例：動態函式生成
下面是一個示例，展示如何使用 AST 轉換動態生成函式：
import ast
def generate_function_from_spec(function_name, operation, operand):
# 建立AST：def function_name(x): return x <operation> operand
arg = ast.arg(arg='x', annotation=None)
arguments = ast.arguments(
posonlyargs=[], args=[arg], kwonlyargs=[], kw_defaults=[], defaults=[]
)
# 建立二元表示式：x <operation> operand
if operation == 'add':
op_node = ast.Add()
value = ast.BinOp(
left=ast.Name(id='x', ctx=ast.Load()),
op=op_node,
right=ast.Num(n=operand)
)
elif operation == 'multiply':
op_node = ast.Mult()
value = ast.BinOp(
left=ast.Name(id='x', ctx=ast.Load()),
op=op_node,
right=ast.Num(n=operand)
)
else:
raise ValueError("Unsupported operation")
func_def = ast.FunctionDef(
name=function_name,
args=arguments,
body=[ast.Return(value=value)],
decorator_list=[]
)
module = ast.Module(body=[func_def], type_ignores=[])
ast.fix_missing_locations(module)
return module
在這個示例中，我們定義了一個generate_function_from_spec函式，該函式接受函式名稱、運算子和運算元為引數。根據這些引數，我們構建了一個 AST，代表一個函式定義。然後，我們使用ast.fix_missing_locations函式修復 AST 中的位置資訊，最後傳回生成的 AST。
動態計算與抽象語法樹操控
在電腦科學中，動態計算是一種強大的工具，允許開發人員根據特定的執行時條件生成最佳化的程式碼。這種模式在需要使用者定義計算的框架中尤其有用，例如科學計算或領域特定模擬環境。透過抽象語法樹（AST）操控，開發人員可以生成根據特定執行時條件最佳化的程式碼。
動態計算範例
以下範例展示了一個動態計算函式的生成，該函式將其引數乘以一個指定值。這種模式在需要使用者定義計算的框架中尤其有用。
import ast
def generate_function_from_spec(name, operator, value):
#...
return module
spec_module = generate_function_from_spec("dynamic_compute", "multiply", 10)
compiled_module = compile(spec_module, filename="<ast>", mode="exec")
exec_globals = {}
exec(compiled_module, exec_globals)
result = exec_globals["dynamic_compute"](5)
print("Dynamic compute result:", result)
這個生成的函式將其引數乘以 10。這種模式在需要使用者定義計算的框架中尤其有用，例如科學計算或領域特定模擬環境。
抽象語法樹操控
抽象語法樹操控支援更複雜的場景，結合程式碼分析、超程式設計和動態生成。例如，現代程式碼編輯器和整合開發環境（IDE）利用抽象語法樹來啟用實時語法檢查、自動完成、重構和安全程式碼轉換等功能。IDE 可以使用一系列抽象語法樹存取器來維護一個 live 符號表、生成呼叫圖以便於導航，或根據指定的風格自動重構程式碼。其中一個關鍵技巧是設計這些轉換，使其可逆，允許使用者在不永久修改程式碼的情況下進行實驗。
領域特定語言（DSL）開發
另一個實際範例是自定義領域特定語言（DSL）的開發。開發人員可以在 Python 中嵌入 DSL 結構，並透過抽象語法樹操控將其轉換為可執行的 Python 程式碼。例如，一個用於查詢資料結構的 DSL 可以使用流暢介面編寫，然後透過一系列抽象語法樹轉換轉換為最佳化形式。這種 DSL 不僅提高了可讀性和領域邏輯的表達能力，也受益於 Python 成熟的執行時環境和工具。
import ast
class DSLTransformer(ast.NodeTransformer):
def visit_Call(self, node):
#...
if isinstance(node.func, ast.Name) and node.func.id == 'query':
#...
new_call = ast.Call(
func=ast.Name(id='process_query', ctx=ast.Load()),
args=node.args,
keywords=node.keywords
)
return self.generic_visit(node)
def process_query(condition):
#...
print("Processing query with condition:", condition)
return lambda data: [item for item in data if eval(condition, {}, {'x': item})]
8.1 瞭解 Descriptor 協定
Python 的 Descriptor 協定是一種精確控制類別屬性存取的機制。Descriptor 是實作了__get__、__set__和__delete__方法的物件。當這些方法被定義時，Descriptor 的例項可以控制類別中的屬性查詢、指派和刪除。
Descriptor 的分類別
Descriptor 可以分為兩類別：資料 Descriptor 和非資料 Descriptor。資料 Descriptor 實作了__get__和__set__（或__delete__）方法，而非資料 Descriptor 只實作了__get__方法。這種區別很重要，因為資料 Descriptor 會覆寫例項變數，即使例項字典中包含同名的條目。
Descriptor 的運作機制
當一個屬性被查詢時，Python 的方法解析順序（MRO）會被擴充套件以檢查該屬性是否是一個 Descriptor。如果是，Python 會自動呼叫 Descriptor 的其中一個方法。假設d是一個實作了__get__的 Descriptor，那麼屬性存取如obj.attr就會被轉換為d.__get__(obj, type(obj))。當設定一個屬性時，如果 Descriptor 定義了__set__，Python 會在寫入例項字典之前先呼叫d.__set__(obj, value)。
實作一個簡單的 Descriptor
以下是一個簡單的 Descriptor 實作，它管理了一個具有型別檢查的屬性：
class IntDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
return instance.__dict__.get(self.name)
def __set__(self, instance, value):
if not isinstance(value, int):
raise TypeError("只能指派整數")
instance.__dict__[self.name] = value
這個 Descriptor 會攔截__set__過程以強制只有整數才能被指派給該屬性。
使用 Descriptor
Descriptor 可以用來實作各種功能，如強制資料一致性、型別正確性或計算值的快取等。以下是一個使用 Descriptor 的例子：
class Person:
age = IntDescriptor("age")
def __init__(self, age):
self.age = age
p = Person(25)
print(p.age) # 25
try:
p.age = "abc"
except TypeError as e:
print(e) # 只能指派整數
在這個例子中，IntDescriptor被用來強制age屬性只能被指派整數。
類別屬性描述器（Descriptor）深度剖析
在 Python 中，描述器（Descriptor）是一種強大的工具，允許開發者自訂屬性存取的行為。描述器可以用來實作資料驗證、懶惰計算（Lazy Evaluation）以及其他高階功能。
基本概念
描述器是一個實作了 __get__、__set__ 和 __delete__ 方法的類別。這些方法分別負責屬性的讀取、寫入和刪除。描述器可以附加到類別的屬性上，以控制存取該屬性的行為。
數值描述器範例
以下是一個簡單的數值描述器範例，該描述器確保屬性只接受整數值：
class IntDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
return instance.__dict__[self.name]
def __set__(self, instance, value):
if not isinstance(value, int):
raise TypeError(f"Expected an integer for {self.name}")
instance.__dict__[self.name] = value
def __delete__(self, instance):
if self.name in instance.__dict__:
del instance.__dict__[self.name]
class Sample:
number = IntDescriptor('number')
s = Sample()
s.number = 42
print(s.number) # 輸出: 42
在這個範例中，IntDescriptor 類別實作了 __get__、__set__ 和 __delete__ 方法，以控制 number 屬性的存取。當試圖將非整數值賦予 number 屬性時，會引發 TypeError。
懶惰計算描述器範例
以下是一個懶惰計算描述器範例，該描述器計算屬性值時，只計算一次，並將結果快取起來：
class LazyProperty:
def __init__(self, function):
self.function = function
self.name = function.__name__
def __get__(self, instance, owner):
if instance is None:
return self
if self.name not in instance.__dict__:
instance.__dict__[self.name] = self.function(instance)
return instance.__dict__[self.name]
class ExpensiveCalculation:
@LazyProperty
def result(self):
return sum(i * i for i in range(1000000))
ec = ExpensiveCalculation()
print(ec.result) # 只計算一次，並將結果快取起來
在這個範例中，LazyProperty 類別實作了 __get__ 方法，以控制 result 屬性的存取。當第一次存取 result 屬性時，會計算屬性值，並將結果快取起來。後續存取 result 屬性時，會直接傳回快取的結果。
8.2 實作基本描述器
在 Python 中，描述器提供了一種機制，允許我們在存取屬性時進行攔截和修改。基本描述器是更複雜的超程式設計技術的基礎，讓我們能夠對屬性管理進行自定義控制。
8.2.1 基本描述器的實作
基本描述器的實作分為三個部分：__get__、__set__ 和 __delete__。這些方法分別負責屬性存取、屬性指定和屬性刪除。
8.2.1.1 __get__ 方法
__get__ 方法負責屬性存取。當我們存取一個屬性時，Python 會檢查是否有對應的描述器，如果有，則會執行描述器的 __get__ 方法。
以下是一個簡單的描述器實作，該描述器會記錄每次屬性存取的時間：
import datetime
class LoggingDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
value = instance.__dict__.get(self.name)
print(f"存取屬性 {self.name} 時間：{datetime.datetime.now()}")
return value
8.2.1.2 __set__ 方法
__set__ 方法負責屬性指定。當我們指定一個屬性時，Python 會檢查是否有對應的描述器，如果有，則會執行描述器的 __set__ 方法。
以下是一個簡單的描述器實作，該描述器會檢查指定的值是否為整數：
class IntegerDescriptor:
def __init__(self, name):
self.name = name
def __set__(self, instance, value):
if not isinstance(value, int):
raise TypeError(f"屬性 {self.name} 必須是整數")
instance.__dict__[self.name] = value
8.2.1.3 __delete__ 方法
__delete__ 方法負責屬性刪除。當我們刪除一個屬性時，Python 會檢查是否有對應的描述器，如果有，則會執行描述器的 __delete__ 方法。
以下是一個簡單的描述器實作，該描述器會記錄每次屬性刪除的時間：
class DeletionDescriptor:
def __init__(self, name):
self.name = name
def __delete__(self, instance):
print(f"刪除屬性 {self.name} 時間：{datetime.datetime.now()}")
del instance.__dict__[self.name]
8.2.2 資料描述器和非資料描述器
Python 中有兩種型別的描述器：資料描述器和非資料描述器。
- 資料描述器：定義了
__get__和__set__(或__delete__) 方法的描述器被稱為資料描述器。資料描述器具有更高的優先順序於例項屬性。 - 非資料描述器：只定義了
__get__方法的描述器被稱為非資料描述器。非資料描述器可能被例項屬性覆寫。
8.2.3 結合使用
我們可以結合使用多個描述器來實作更複雜的功能。例如，我們可以使用一個資料描述器來檢查指定的值是否為整數，並使用另一個非資料描述器來記錄每次屬性存取的時間。
class User:
username = LoggingDescriptor("username")
age = IntegerDescriptor("age")
user = User()
user.username = "John"
user.age = 30
print(user.username)
print(user.age)
在這個例子中，username 屬性使用了 LoggingDescriptor 來記錄每次存取的時間，而 age 屬性使用了 IntegerDescriptor 來檢查指定的值是否為整數。
屬性描述器的應用：增強類別屬性的控制和彈性
在 Python 中，描述器（descriptor）是一種強大的工具，允許開發者定製屬性的存取和修改行為。透過實作描述器 protocol，開發者可以建立自定義的屬性存取控制機制，從而增強類別屬性的控制和彈性。
實作 LoggingDescriptor
首先，我們來實作一個簡單的 LoggingDescriptor，它可以在存取屬性時記錄日誌：
class LoggingDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
value = instance.__dict__.get(self.name)
print(f"Accessing {self.name}, value: {value}")
return value
def __set__(self, instance, value):
instance.__dict__[self.name] = value
print(f"Setting {self.name} to {value}")
這個 LoggingDescriptor 會在存取屬性時記錄日誌，並且在設定屬性值時也會記錄日誌。
Integrating LoggingDescriptor into a class
要將 LoggingDescriptor 整合到一個類別中，需要在類別定義中使用描述器：
class MyClass:
attr = LoggingDescriptor("attr")
def __init__(self):
self.attr = "initial value"
這樣，當我們存取或修改 attr 屬性時，就會觸發 LoggingDescriptor 的 __get__ 和 __set__ 方法，記錄日誌。
實作 TypedDescriptor
接下來，我們來實作一個 TypedDescriptor，它可以在設定屬性值時驗證值的型別：
class TypedDescriptor:
def __init__(self, name, expected_type):
self.name = name
self.expected_type = expected_type
def __get__(self, instance, owner):
if instance is None:
return self
return instance.__dict__.get(self.name)
def __set__(self, instance, value):
if not isinstance(value, self.expected_type):
raise TypeError(f"Expected value of type {self.expected_type.__name__}, but got {type(value).__name__}")
instance.__dict__[self.name] = value
這個 TypedDescriptor 會在設定屬性值時驗證值的型別，如果型別不匹配，就會引發 TypeError。
實作 ResourceDescriptor
最後，我們來實作一個 ResourceDescriptor，它可以在刪除屬性時執行清理操作：
class ResourceDescriptor:
def __init__(self, name, release_callback):
self.name = name
self.release_callback = release_callback
def __get__(self, instance, owner):
if instance is None:
return self
return instance.__dict__.get(self.name)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
def __delete__(self, instance):
if self.release_callback:
self.release_callback(instance)
del instance.__dict__[self.name]
這個 ResourceDescriptor 會在刪除屬性時執行清理操作，例如釋放資源。
屬性描述器（Descriptor）在 Python 中的應用
在 Python 中，屬性描述器（Descriptor）是一種強大的工具，允許開發者自定義屬性的行為和存取控制。透過實作 __get__、__set__ 和 __delete__ 方法，開發者可以對屬性進行嚴格的控制和管理。
從技術架構視角來看，Python 的描述器（Descriptor）機制提供了一種優雅且強大的方法，允許開發者深入控制物件屬性的存取和修改行為。本文深入探討了描述器的不同型別，包括資料描述器和非資料描述器，並闡述了它們在屬性查詢、指定和刪除過程中的運作機制。同時，文章也展示瞭如何利用描述器實作型別檢查、日誌記錄、懶惰計算以及資源管理等實用功能，顯著提升了程式碼的彈性和可維護性。然而，描述器的使用也存在潛在的效能損耗，尤其是在頻繁存取屬性的場景下。因此，在實際應用中，需要權衡描述器帶來的效益與效能影響。描述器機制將持續在 Python 的超程式設計和框架開發中扮演重要角色，隨著更多開發者深入理解和應用，預期將會出現更多根據描述器的創新設計模式和實務應用。對於追求程式碼品質和設計彈性的開發者而言，深入掌握描述器機制將是提升 Python 開發技能的關鍵一步。玄貓認為，描述器雖略微增加了程式碼的複雜度，但其所賦予的細粒度控制能力和程式碼重用性，使其成為 Python 開發者工具箱中不可或缺的利器。
