描述符是 Python 的進階特性，能有效管理類別屬性存取和程式碼重用。然而，描述符本身作為類別屬性，存在所有例項分享同一描述符物件的潛在問題。如果描述符直接儲存資料，修改一個例項的屬性會影響所有其他例項，造成非預期的行為。為避免此問題，應將資料儲存在例項的 __dict__ 屬性中，或使用 WeakKeyDictionary 儲存例項資料與描述符的對映關係，確保每個例項擁有獨立的資料儲存空間，避免資料汙染。
from weakref import WeakKeyDictionary
class Descriptor:
def __init__(self, initial_value):
self.initial_value = initial_value
self.data = WeakKeyDictionary()
def __get__(self, instance, owner):
if instance is None:
return self
return self.data.get(instance, self.initial_value)
def __set__(self, instance, value):
self.data[instance] = value
描述符的分享狀態問題與實作考量
在前面的章節中，我們已經討論了描述符（Descriptor）的基本概念以及如何使用它們來控制對類別屬性的存取。然而，當我們探討描述符的實作細節時，會遇到一個重要的問題：分享狀態。
分享狀態的問題
描述符需要被設定為類別屬性才能正常運作，這意味著所有該類別的例項都會分享同一個描述符物件。如果描述符物件本身儲存資料，那麼所有例項都會存取相同的資料。這可能會導致意想不到的後果。
錯誤的描述符實作範例
class SharedDataDescriptor:
def __init__(self, initial_value):
self.value = initial_value
def __get__(self, instance, owner):
if instance is None:
return self
return self.value
def __set__(self, instance, value):
self.value = value
class ClientClass:
descriptor = SharedDataDescriptor("first value")
在這個範例中，描述符物件 SharedDataDescriptor 儲存資料本身。當我們修改某個例項的 descriptor 屬性時，所有其他例項的 descriptor 屬性也會被修改。
>>> client1 = ClientClass()
>>> client1.descriptor
'first value'
>>> client2 = ClientClass()
>>> client2.descriptor
'first value'
>>> client2.descriptor = "value for client 2"
>>> client2.descriptor
'value for client 2'
>>> client1.descriptor
'value for client 2'
正確的描述符實作方法
為了避免分享狀態的問題，描述符應該將資料儲存在每個例項的 __dict__ 屬性中，並從中檢索資料。
class CorrectDescriptor:
def __init__(self, initial_value):
self.initial_value = initial_value
def __get__(self, instance, owner):
if instance is None:
return self
return instance.__dict__.get('descriptor', self.initial_value)
def __set__(self, instance, value):
instance.__dict__['descriptor'] = value
使用弱參照（Weak References）
另一種方法是使用弱參照字典（WeakKeyDictionary）來儲存每個例項的資料。
from weakref import WeakKeyDictionary
class DescriptorClass:
def __init__(self, initial_value):
self.value = initial_value
self.mapping = WeakKeyDictionary()
def __get__(self, instance, owner):
if instance is None:
return self
return self.mapping.get(instance, self.value)
def __set__(self, instance, value):
self.mapping[instance] = value
描述符的優缺點與使用時機
描述符是一種強大的工具，可以用來避免程式碼重複。它們可以用來實作屬性邏輯，並且可以根據需要進行擴充套件。
重用程式碼
描述符可以用來重用程式碼，特別是在需要多次使用相同屬性邏輯的情況下。它們提供了一種通用的解決方案，可以簡化程式碼並提高可維護性。
使用描述符的最佳時機
當你需要在多個類別或屬性中重用相同的邏輯時，描述符是一個很好的選擇。它們也適用於需要對屬性存取進行精細控制的情況。
內容解密：
此圖示呈現了描述符的使用時機與優缺點之間的關係。首先，描述符可以用於需要重複使用相同邏輯的多個類別或屬性。其次，使用描述符可以簡化程式碼並提高可維護性。然而，需要注意的是，描述符也可能引入額外的複雜性，因此應該謹慎使用。
@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle
title Python 描述符分享狀態問題與實作
package "物件導向程式設計" {
package "核心概念" {
component [類別 Class] as class
component [物件 Object] as object
component [屬性 Attribute] as attr
component [方法 Method] as method
}
package "三大特性" {
component [封裝
Encapsulation] as encap
component [繼承
Inheritance] as inherit
component [多型
Polymorphism] as poly
}
package "設計原則" {
component [SOLID] as solid
component [DRY] as dry
component [KISS] as kiss
}
}
class --> object : 實例化
object --> attr : 資料
object --> method : 行為
class --> encap : 隱藏內部
class --> inherit : 擴展功能
inherit --> poly : 覆寫方法
solid --> dry : 設計模式
note right of solid
S: 單一職責
O: 開放封閉
L: 里氏替換
I: 介面隔離
D: 依賴反轉
end note
@enduml
此圖示顯示了描述符的主要優點（重用程式碼和精細控制屬性存取）以及可能的缺點（增加複雜性）。透過瞭解這些因素，可以更好地決定何時使用描述符。
描述符在 Python 中的應用：以登入事件序列化為例
描述符（Descriptor）是 Python 中一個強大的工具，用於重用程式碼並實作更靈活的物件屬性管理。在本篇文章中，我們將探討如何利用描述符來簡化程式碼並提高可維護性，特別是在處理物件序列化的場景下。
描述符的基本概念
描述符是一種特殊的類別，用於實作物件屬性的 getter 和 setter 方法。透過定義 __get__、__set__ 和 __set_name__ 方法，我們可以控制屬性的讀取和寫入行為。
使用描述符簡化序列化邏輯
在處理登入事件（LoginEvent）物件時，我們需要對某些屬性進行序列化處理，例如隱藏敏感資訊或格式化日期。傳統上，我們可能會使用裝飾器（Decorator）來實作這一點。然而，描述符提供了一種更為靈活和可擴充套件的方案。
實作描述符類別
首先，我們定義一個基礎的描述符類別 BaseFieldTransformation，它接受一個轉換函式（transformation function）作為引數。這個類別實作了 __get__ 和 __set__ 方法，以控制屬性的讀取和寫入。
from dataclasses import dataclass
from datetime import datetime
from functools import partial
from typing import Callable
class BaseFieldTransformation:
def __init__(self, transformation: Callable[[str], str]) -> None:
self._name = None
self.transformation = transformation
def __get__(self, instance, owner):
if instance is None:
return self
raw_value = instance.__dict__[self._name]
return self.transformation(raw_value)
def __set_name__(self, owner, name):
self._name = name
def __set__(self, instance, value):
instance.__dict__[self._name] = value
ShowOriginal = partial(BaseFieldTransformation, transformation=lambda x: x)
HideField = partial(BaseFieldTransformation, transformation=lambda x: "**redacted**")
FormatTime = partial(BaseFieldTransformation, transformation=lambda ft: ft.strftime("%Y-%m-%d %H:%M"))
應用描述符於登入事件類別
接下來，我們定義 LoginEvent 類別，並使用上述描述符來管理其屬性。
@dataclass
class LoginEvent:
username: str = ShowOriginal()
password: str = HideField()
ip: str = ShowOriginal()
timestamp: datetime = FormatTime()
def serialize(self) -> dict:
return {
"username": self.username,
"password": self.password,
"ip": self.ip,
"timestamp": self.timestamp,
}
#### 內容解密：
BaseFieldTransformation類別定義了描述符的基本行為，包括屬性的讀取和寫入。- 透過
partial函式，我們建立了ShowOriginal、HideField和FormatTime等具體的描述符類別，每個類別對應不同的轉換邏輯。 - 在
LoginEvent類別中，我們使用這些描述符來管理屬性，確保在序列化時套用正確的轉換。
執行結果與分析
當我們建立一個 LoginEvent 物件並呼叫其 serialize 方法時，描述符會自動套用相應的轉換邏輯。
>>> le = LoginEvent("john", "secret password", "1.1.1.1", datetime(2023, 4, 1, 12, 0))
>>> vars(le)
{'username': 'john', 'password': 'secret password', 'ip': '1.1.1.1', 'timestamp': datetime.datetime(2023, 4, 1, 12, 0)}
>>> le.serialize()
{'username': 'john', 'password': '**redacted**', 'ip': '1.1.1.1', 'timestamp': '2023-04-01 12:00'}
>>> le.password
'**redacted**'
#### 內容解密：
- 當我們直接存取
le.password時，描述符會傳回經過轉換的值（**redacted**）。 - 在
serialize方法中，描述符同樣會套用轉換邏輯，確保序列化結果的正確性。
深入理解Python描述器（Descriptor）
在Python中，描述器（Descriptor）是一種強大的工具，可以幫助我們簡化程式碼、抽象重複邏輯以及實作更為緊湊的類別設計。本文將探討描述器的內部工作原理、應用場景以及如何正確地使用它們。
描述器的基本概念
描述器是一種實作了__get__、__set__或__delete__方法的物件。這些方法允許描述器控制對類別屬性的存取。在本文中，我們將探討描述器的基本概念以及如何使用它們來簡化程式碼。
使用描述器簡化程式碼
假設我們需要實作一個事件類別，該類別具有多個屬性，每個屬性都需要進行特定的處理（例如，格式化、隱藏或顯示原始值）。使用描述器，我們可以將這些處理邏輯抽象出來，從而簡化事件類別的實作。
class BaseEvent:
def __init__(self, name):
self.name = name
def serialize(self):
# 序列化邏輯
pass
class LoginEvent(BaseEvent):
username = ShowOriginal()
password = HideField()
ip = ShowOriginal()
timestamp = FormatTime()
在上面的例子中，LoginEvent類別使用了描述器來定義其屬性。每個描述器負責處理其對應屬性的邏輯，從而使得LoginEvent類別的實作更加簡潔。
分析描述器
為了確保我們的描述器實作是正確且高效的，我們需要了解Python內部如何使用描述器。
Python內部如何使用描述器
Python內部廣泛使用描述器來實作各種功能，例如函式和方法。事實上，函式本身就是描述器，它們實作了__get__方法，使得它們可以作為方法繫結到類別例項上。
函式和方法
當我們在類別中定義一個方法時，Python會將其轉換為一個繫結方法（bound method）。這個過程是由描述器協定（descriptor protocol）控制的。
class MyClass:
def method(self, arg1, arg2):
print(f"Method called with {arg1} and {arg2}")
# 等同於
class MyClass: pass
def method(myclass_instance, arg1, arg2):
print(f"Method called with {arg1} and {arg2}")
MyClass.method = method
在上面的例子中，method函式被轉換為一個繫結方法，該方法將myclass_instance作為其第一個引數。
正確使用描述器
要正確使用描述器，我們需要了解其內部工作原理以及如何設計良好的描述器。
設計良好的描述器
一個良好的描述器應該是簡潔、一致且易於理解的。它應該遵循Python的設計原則，並且應該與Python的其他部分保持一致。
例項分析
讓我們考慮一個例子，其中我們定義了一個名為Method的類別，該類別充當一個可呼叫的物件（callable object）。
class Method:
def __init__(self, name):
self.name = name
def __call__(self, instance, arg1, arg2):
print(f"{self.name}: {instance} called with {arg1} and {arg2}")
class MyClass:
method = Method("Internal call")
在這個例子中，Method類別實作了__call__方法，使其成為一個可呼叫的物件。當我們在MyClass類別中定義method屬性時，它實際上是一個Method例項。
內容解密：
- 描述器的基本概念：描述器是一種實作了特定方法的物件，用於控制對類別屬性的存取。
- 使用描述器簡化程式碼：描述器可以將重複的邏輯抽象出來，從而簡化類別的實作。
- Python內部如何使用描述器：Python內部廣泛使用描述器來實作各種功能，例如函式和方法。
- 正確使用描述器：瞭解描述器的內部工作原理以及如何設計良好的描述器對於正確使用它們至關重要。
描述器在Python中的應用與實作
在Python中，描述器（Descriptor）是一種強大的工具，用於實作屬性的存取控制、方法的繫結等功能。本文將探討描述器的原理、實作方式以及在實際開發中的應用。
描述器的基本原理
描述器是一種特殊型別的物件，它定義了屬性或方法的存取行為。當一個類別屬性被定義為描述器時，Python會自動呼叫描述器的__get__、__set__或__delete__方法來控制屬性的存取。
簡單的描述器範例
class Method:
def __init__(self, name):
self.name = name
def __call__(self, instance, arg1, arg2):
print(f"{self.name}: {instance} called with {arg1} and {arg2}")
def __get__(self, instance, owner):
if instance is None:
return self
return MethodType(self, instance)
class MyClass:
method = Method("External call")
instance = MyClass()
MyClass.method(instance, "first", "second") # 正確呼叫
instance.method("first", "second") # 正確呼叫
內容解密：
Method類別實作了__call__方法，使其成為可呼叫的物件。__get__方法用於繫結方法到例項，傳回一個MethodType物件。- 當透過例項呼叫
method時，Python自動呼叫__get__方法進行方法繫結。
內建裝飾器與描述器
Python中的內建裝飾器如@property、@classmethod和@staticmethod都是透過描述器實作的。
自定義@classproperty裝飾器
class classproperty:
def __init__(self, fget):
self.fget = fget
def __get__(self, instance, owner):
return self.fget(owner)
class TableEvent:
schema = "public"
table = "user"
@classproperty
def topic(cls):
prefix = read_prefix_from_config()
return f"{prefix}{cls.schema}.{cls.table}"
print(TableEvent.topic) # 正確輸出
print(TableEvent().topic) # 正確輸出
內容解密：
classproperty類別實作了描述器協定，使其能夠作為類別屬性的裝飾器。__get__方法直接呼叫被裝飾的方法，並傳入類別作為引數。
使用__slots__最佳化記憶體使用
__slots__是一種類別屬性，用於定義物件的固定屬性集合，從而避免動態屬性帶來的記憶體浪費。
__slots__範例
class MyClass:
__slots__ = ('attr1', 'attr2')
obj = MyClass()
obj.attr1 = 'value1' # 允許
try:
obj.attr3 = 'value3' # 丟擲AttributeError
except AttributeError:
print("Cannot add attribute not defined in __slots__")
內容解密：
__slots__定義了物件允許的屬性名稱。- 嘗試新增未在
__slots__中定義的屬性會導致AttributeError。