Python 描述器提供一種控制屬性存取的彈性機制，其行為會根據存取的上下文而有所不同。在例項層級，描述器可以根據例項狀態計算屬性值；而在類別層級，則可實作靜態屬性或方法。結合屬性裝飾器，更能實作記錄存取、型別檢查等進階功能。混合描述器模式能巧妙地結合靜態和例項屬性，方便管理不同層級的資料和行為。配合元類別，更可在類別初始化時，根據預設策略自動包裝屬性，強化程式碼一致性和可維護性。更進一步，描述器也能應用於檔案資源管理，自動化開啟和關閉檔案，簡化程式碼並提升安全性。
8.4 類別和靜態內容中的描述器
描述器（Descriptor）是一種強大的機制，能夠控制屬性存取和修改。在類別和靜態內容中，描述器的行為會根據存取的內容有所不同。在例項內容中，描述器通常會介紹例項狀態的屬性存取，而在靜態內容中，描述器的行為可能會有所不同或簡化。
例項內容中的描述器
在例項內容中，描述器的 __get__ 方法會接收到例項物件作為其第一個引數。描述器可以根據例項的狀態來計算或取得屬性的值。例如，以下是一個簡單的描述器，它會根據例項的狀態來計算屬性的值：
class InstanceDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
# 根據例項狀態計算屬性的值
return instance.__dict__.get(self.name, None)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
靜態內容中的描述器
在靜態內容中，描述器的 __get__ 方法不會接收到例項物件作為其第一個引數，而是會接收到 None。描述器可以根據這個差異來實作不同的行為。例如，以下是一個簡單的描述器，它會在靜態內容中傳回描述器本身，而在例項內容中傳回屬性的值：
class DualContextDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
# 在靜態內容中傳回描述器本身
return self
# 在例項內容中傳回屬性的值
return instance.__dict__.get(self.name, None)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
結合使用描述器和屬性裝飾器
描述器可以與屬性裝飾器結合使用，以實作更複雜的屬性存取控制。例如，以下是一個簡單的描述器，它會使用屬性裝飾器來記錄屬性的存取：
def log_access(func):
def wrapper(self):
print(f"Accessing {func.__name__}")
return func(self)
return wrapper
class LoggingDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
# 使用屬性裝飾器記錄屬性的存取
@log_access
def getter(self):
return instance.__dict__.get(self.name, None)
return getter(instance)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
類別屬性存取控制：使用描述器（Descriptor）實作混合行為
在 Python 中，描述器（Descriptor）是一種強大的工具，允許開發者控制存取類別屬性的行為。描述器可以用來實作各種高階功能，例如屬性驗證、計算屬性和類別層級的常數。
基本描述器
首先，我們來看一個基本的描述器實作：
class DualContextDescriptor:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
# 在類別層級存取
return self.name
else:
# 在例項層級存取
return instance.__dict__[self.name]
def __set__(self, instance, value):
instance.__dict__[self.name] = value
def __delete__(self, instance):
if self.name in instance.__dict__:
del instance.__dict__[self.name]
這個描述器允許我們在類別層級和例項層級存取屬性。
靜態快取描述器
接下來，我們來看一個靜態快取描述器的實作：
class StaticCacheDescriptor:
def __init__(self, name, compute_func):
self.name = name
self.cached_value = None
self.compute_func = compute_func
def __get__(self, instance, owner):
if instance is None:
# 在類別層級存取
if self.cached_value is None:
self.cached_value = self.compute_func()
return self.cached_value
else:
# 在例項層級存取
return instance.__dict__[self.name]
def __set__(self, instance, value):
instance.__dict__[self.name] = value
這個描述器使用靜態快取來儲存計算結果，以避免重複計算。
混合描述器
最後，我們來看一個混合描述器的實作：
class HybridDescriptor:
def __init__(self, name, default_factory, is_static=False):
self.name = name
self.default_factory = default_factory
self.is_static = is_static
self._static_value = None
def __get__(self, instance, owner):
if instance is None:
# 在類別層級存取
if self._static_value is None:
self._static_value = self.default_factory()
return self._static_value
else:
# 在例項層級存取
return instance.__dict__[self.name]
def __set__(self, instance, value):
instance.__dict__[self.name] = value
這個描述器允許我們在類別層級和例項層級存取屬性，並且可以根據 is_static 引數決定是否使用靜態快取。
混合描述符模式：實作靜態和例項屬性共存
在導向物件的程式設計中，描述符（Descriptor）是一種強大的工具，允許開發者定製屬性存取和修改的行為。混合描述符（Hybrid Descriptor）是一種特殊的描述符，它可以根據上下文在靜態和例項屬性之間切換。這種模式對於需要在類別層級維護不變的屬性同時允許例項層級的可變屬性非常有用。
混合描述符的實作
class HybridDescriptor:
def __init__(self, name, default_factory, is_static=False):
self.name = name
self.default_factory = default_factory
self.is_static = is_static
self._static_value = None
def __get__(self, instance, owner):
if self.is_static or instance is None:
if self._static_value is None:
self._static_value = self.default_factory(owner)
return self._static_value
return instance.__dict__.get(self.name, self.default_factory(instance))
def __set__(self, instance, value):
if self.is_static:
raise AttributeError(f"{self.name} is a static attribute and cannot be reassigned")
instance.__dict__[self.name] = value
def __delete__(self, instance):
if self.is_static:
raise AttributeError(f"{self.name} is a static attribute and cannot be deleted")
if self.name in instance.__dict__:
del instance.__dict__[self.name]
這個實作提供了一個基礎的混合描述符，根據 is_static 標誌決定是否以靜態模式運作。當 is_static 為 True 時，描述符會維護一個類別層級的靜態值；否則，它會允許例項層級的可變屬性。
與元類別結合：強制執行類別層級政策
描述符可以與元類別結合，實作類別層級的政策強制執行。元類別可以在初始化時遍歷類別屬性，並根據需要包裝選定的屬性以特殊描述符。這種方法有效地將屬性行為與核心業務邏輯分離，使得根據類別層級的後設資料進行動態適應成為可能。
例如，以下是一個簡單的元類別，它自動為某些型別的屬性增加了不可變的描述符：
class ImmutableMeta(type):
def __new__(meta, name, bases, class_dict):
for key, value in class_dict.items():
if isinstance(value, (int, str, float)):
class_dict[key] = ReadOnly(key)
return type.__new__(meta, name, bases, class_dict)
class ReadOnly:
def __init__(self, name):
self.name = name
def __get__(self, instance, owner):
return instance.__dict__.get(self.name)
def __set__(self, instance, value):
raise AttributeError(f"{self.name} is read-only and cannot be modified")
這個元類別會自動將所有整數、字串和浮點數型別的屬性包裝在一個只讀描述符中，從而確保這些屬性在類別層級上是不可變的。
圖表翻譯：混合描述符模式架構
flowchart TD
A[類別定義] --> B[混合描述符]
B --> C[靜態屬性存取]
B --> D[例項屬性存取]
C --> E[類別層級政策強制執行]
D --> F[例項層級可變屬性]
E --> G[元類別初始化]
G --> H[自動包裝選定屬性]
這個圖表展示了混合描述符模式的架構，包括靜態和例項屬性的存取，以及與元類別的結合以強制執行類別層級政策。
屬性描述器與元類別的應用
在 Python 中，描述器（descriptor）是一種強大的工具，允許你定義物件屬性的存取行為。描述器可以用來實作屬性的 getter、setter 和 deleter 方法。下面是一個使用描述器和元類別（metaclass）來實作屬性不可變性（immutability）的例子。
屬性描述器的實作
class ImmutableDescriptor:
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 self.name in instance.__dict__:
raise AttributeError(f"{self.name} is read-only")
instance.__dict__[self.name] = value
def __delete__(self, instance):
raise AttributeError(f"Cannot delete read-only attribute {self.name}")
元類別的應用
元類別（metaclass）是一種用於建立類別的類別。它可以用來定義類別的行為和屬性。下面是一個使用元類別來將選定的類別屬性轉換為描述器的例子。
class ImmutableMeta(type):
def __new__(cls, name, bases, attrs):
for attr_name, attr_value in attrs.items():
if isinstance(attr_value, str) or isinstance(attr_value, int):
attrs[attr_name] = ImmutableDescriptor(attr_name)
return super().__new__(cls, name, bases, attrs)
class Config(metaclass=ImmutableMeta):
host = "localhost"
port = 8080
在這個例子中，ImmutableMeta 元類別會將 Config 類別中的 host 和 port 屬性轉換為描述器。這些描述器會實作屬性的不可變性。
上下文敏感日誌機制
描述器也可以用來實作上下文敏感日誌機制。下面是一個使用描述器來實作日誌機制的例子。
class ContextSensitiveLogger:
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"[Instance Log] Getting value of '{self.name}': {value}")
return value
在這個例子中，ContextSensitiveLogger 類別會實作一個日誌機制，當屬性被存取時，會列印預出一條日誌訊息。
內容解密：
ImmutableDescriptor類別實作了屬性的 getter、setter 和 deleter 方法，以實作屬性的不可變性。ImmutableMeta元類別會將選定的類別屬性轉換為描述器，以實作屬性的不可變性。ContextSensitiveLogger類別實作了上下文敏感日誌機制，當屬性被存取時，會列印預出一條日誌訊息。
圖表翻譯：
classDiagram
class ImmutableDescriptor {
-name: str
+__init__(name: str)
+__get__(instance, owner)
+__set__(instance, value)
+__delete__(instance)
}
class ImmutableMeta {
+__new__(name, bases, attrs)
}
class Config {
-host: str
-port: int
}
class ContextSensitiveLogger {
-name: str
+__init__(name: str)
+__get__(instance, owner)
}
這個圖表展示了各個類別之間的關係，以及每個類別的屬性和方法。
高階描述符技術
描述符（descriptor）是一種強大的工具，能夠控制物件屬性的存取和管理。在 Python 中，描述符可以用於實作各種高階功能，例如資源管理、代理複雜互動和屬性委派。
資源管理
描述符可以用於控制外部資源的取得和釋放。例如，可以建立一個描述符來管理檔案控制程式碼，確保檔案在屬性被刪除或更新時正確關閉。下面是一個示例：
class FileResource:
def __init__(self, filename, mode='r'):
self.filename = filename
self.mode = mode
def open(self):
# 開啟檔案
self.file = open(self.filename, self.mode)
def close(self):
# 關閉檔案
self.file.close()
def __get__(self, instance, owner):
# 取得檔案控制程式碼
return self.file
def __set__(self, instance, value):
# 更新檔案內容
self.file.seek(0)
self.file.write(value)
def __delete__(self, instance):
# 刪除檔案控制程式碼
self.close()
這個描述符可以用於管理檔案控制程式碼，確保檔案在屬性被刪除或更新時正確關閉。
代理複雜互動
描述符可以用於代理複雜互動，例如與外部系統的互動。例如，可以建立一個描述符來代理與資料函式庫的互動，提供簡單的介面來存取資料。下面是一個示例：
class DatabaseProxy:
def __init__(self, db_connection):
self.db_connection = db_connection
def __get__(self, instance, owner):
# 取得資料函式庫連線
return self.db_connection
def __set__(self, instance, value):
# 更新資料函式庫內容
self.db_connection.execute("UPDATE table SET value = %s", (value,))
def __delete__(self, instance):
# 刪除資料函式庫連線
self.db_connection.close()
這個描述符可以用於代理與資料函式庫的互動，提供簡單的介面來存取資料。
屬性委派
描述符可以用於委派屬性給底層元件。例如，可以建立一個描述符來委派屬性給底層物件，提供簡單的介面來存取屬性。下面是一個示例：
class DelegateDescriptor:
def __init__(self, delegate):
self.delegate = delegate
def __get__(self, instance, owner):
# 取得屬性值
return self.delegate.get_attribute()
def __set__(self, instance, value):
# 更新屬性值
self.delegate.set_attribute(value)
def __delete__(self, instance):
# 刪除屬性值
self.delegate.delete_attribute()
這個描述符可以用於委派屬性給底層元件，提供簡單的介面來存取屬性。
內容解密：
- 描述符（descriptor）是一種特殊的物件，它可以控制其他物件的屬性的存取和管理。
- 資源管理描述符可以用於控制外部資源的取得和釋放，例如檔案控制程式碼或資料函式庫連線。
- 代理複雜互動描述符可以用於代理與外部系統的互動，例如資料函式庫或網路服務。
- 屬性委派描述符可以用於委派屬性給底層元件，提供簡單的介面來存取屬性。
圖表翻譯：
flowchart TD
A[描述符] --> B[資源管理]
B --> C[代理複雜互動]
C --> D[屬性委派]
D --> E[簡化程式設計]
E --> F[維護]
這個圖表展示了描述符的不同應用場景，包括資源管理、代理複雜互動和屬性委派，並展示瞭如何簡化程式設計和維護。
使用描述器管理檔案資源
在 Python 中，描述器（descriptor）是一種強大的工具，允許您自訂存取屬性的行為。以下是使用描述器來管理檔案資源的範例。
檔案描述器類別
class FileDescriptor:
def __init__(self, filename, mode='r'):
self.filename = filename
self.mode = mode
def __get__(self, instance, owner):
if instance is None:
return self
# 取得快取的資源，如果可用
resource = instance.__dict__.get(self.filename)
if resource is None:
# 如果資源不存在，建立新的檔案資源
resource = self._open_file()
instance.__dict__[self.filename] = resource
return resource
def __set__(self, instance, value):
# 在指派時，關閉目前的資源，如果需要
current = instance.__dict__.get(self.filename)
if current:
try:
current.close()
except Exception:
pass
instance.__dict__[self.filename] = value
def __delete__(self, instance):
resource = instance.__dict__.pop(self.filename, None)
if resource:
try:
resource.close()
except Exception:
pass
def _open_file(self):
# 開啟檔案並傳回檔案物件
return open(self.filename, self.mode)
使用檔案描述器
class MyClass:
file = FileDescriptor('example.txt', 'r')
obj = MyClass()
print(obj.file) # 列印檔案物件
# 存取檔案內容
with obj.file as f:
print(f.read())
# 關閉檔案
obj.file.close()
內容解密：
上述程式碼定義了一個 FileDescriptor 類別，該類別負責管理檔案資源。當您存取 file 屬性時，描述器會自動開啟檔案並傳回檔案物件。如果檔案已經開啟，描述器會傳回現有的檔案物件。
當您指派新的值給 file 屬性時，描述器會關閉目前的檔案並更新屬性值。如果您刪除 file 屬性，描述器會關閉檔案並移除屬性。
這個範例展示瞭如何使用描述器來管理檔案資源，並確保檔案在不再需要時被正確關閉。
圖表翻譯：
sequenceDiagram
participant FileDescriptor as "檔案描述器"
participant MyClass as "MyClass 物件"
participant File as "檔案物件"
Note over FileDescriptor,MyClass: 存取 file 屬性
FileDescriptor->>File: 開啟檔案
File->>MyClass: 傳回檔案物件
Note over MyClass,File: 存取檔案內容
MyClass->>File: 讀取檔案內容
Note over FileDescriptor,MyClass: 關閉檔案
FileDescriptor->>File: 關閉檔案
這個圖表展示了檔案描述器、MyClass 物件和檔案物件之間的互動。當您存取 file 屬性時，描述器會開啟檔案並傳回檔案物件。當您存取檔案內容時，MyClass 物件會讀取檔案內容。當您關閉檔案時，描述器會關閉檔案。
從系統架構的視角來看，Python 描述器提供了一種優雅的機制，允許開發者在不修改類別介面的前提下，精細地控制屬性存取行為。本文深入探討了描述器在不同上下文中的行為差異，涵蓋了例項屬性、靜態屬性以及混合模式的應用場景。分析顯示，描述器不僅可以簡化程式碼，提升程式碼的可讀性，更重要的是，它能夠實作許多高階功能，例如屬性驗證、延遲計算、日誌記錄和資源管理，有效地提升了程式碼的健壯性和可維護性。然而，描述器的使用也存在一些挑戰，例如除錯的複雜度略高，需要開發者對描述器協定有深入的理解。描述器機制有望在更廣泛的領域得到應用，例如建構更複雜的狀態管理系統、實作更精細的許可權控制以及開發更具彈性的資料模型。對於追求程式碼品質和效能的開發者而言，深入理解和應用描述器將是提升程式設計技能的關鍵一步。玄貓認為，描述器雖小，但其蘊含的設計理念和應用價值卻不容小覷，值得每一位 Python 開發者深入學習和探索。
