So verwenden Sie Deskriptoren in Python-Python-Tutorial-php.cn

Übersicht

Ein Deskriptor ist ein Python-Objekt, das die Operationen definiert, die beim Zugriff auf die Eigenschaften anderer Objekte ausgeführt werden sollen. Mithilfe von Deskriptoren können Sie verschiedene Verhaltensweisen implementieren, z. B. das Berechnen von Eigenschaften, das Zwischenspeichern von Eigenschaftswerten und das Steuern des Eigenschaftszugriffs. Verwenden Sie Deskriptoren, um das Verhalten beim Zugriff auf Eigenschaften anzupassen und zu vermeiden, dass für jede Eigenschaftsverwendung doppelter Code geschrieben wird.

Attribute jeder Klasse, einschließlich Instanzattribute, Klassenattribute und statische Attribute, können Deskriptoren verwenden. Deskriptoren in der Python-Programmierung sind erweiterte Funktionen, die für Programmierer mit umfassenden Kenntnissen der Python-Sprache und fortgeschrittenen Programmierkenntnissen sehr nützlich sind.

Implementierungsmethode

Python-Deskriptoren werden durch Implementierung des Deskriptorprotokolls definiert. Das Deskriptorprotokoll ist eine Art Python-Objektprotokoll. Es definiert drei Methoden: __get__(), __set__() und __delete__() . __get__()、__set__()和__delete__()。

Python解释器在访问一个对象的属性时，会先检查该属性是否是一个描述器。如果属性是描述器，则调用__get__()方法获取属性值。如果属性不是描述器，则直接返回属性值。

如果我们想要使用一个Python描述器来控制属性访问行为，我们需要实现描述器协议中的__get__()、__set__()和__delete__()方法中的至少一个方法。下面是这些方法的具体说明：

__get__(self, instance, owner)：用于获取属性值。如果访问属性的是一个实例，则instance参数是实例对象，owner参数是类对象。如果访问属性的是一个类，则instance参数是None，owner参数是类对象。

__set__(self, instance, value)：用于设置属性值。如果设置属性值的是一个实例，则instance参数是实例对象，value参数是要设置的值。如果设置属性值的是一个类，则instance参数是None，value参数是要设置的值。

__delete__(self, instance)：用于删除属性值。如果删除属性值的是一个实例，则instance参数是实例对象。如果删除属性值的是一个类，则instance参数是None。
如何使用Python描述器

应用场景

Python的描述器可应用于多种情境，例如计算属性、缓存属性值和实现属性的访问控制。下面是一些使用Python描述器的示例。

计算属性

计算属性是一个由其他属性计算得出的属性。举例来说，使用一个描述器可以创建一个计算属性，该属性将两个数字属性相加。下面是一个实现计算属性的示例代码：

class SumDescriptor:  
    def __init__(self, a, b):  
        self.a = a  
        self.b = b  
     
    def __get__(self, instance, owner):  
        return getattr(instance, self.a) + getattr(instance, self.b)  
     
class MyClass:  
    def __init__(self, a, b):  
        self.a = a  
        self.b = b  
        self.sum = SumDescriptor(&#39;a&#39;, &#39;b&#39;)

Nach dem Login kopieren

在上面的代码中，SumDescriptor是一个描述器，它使用__get__()方法来计算a和b属性的和。MyClass是一个包含a和b属性的类，它还定义了一个sum属性，该属性是SumDescriptor的实例。

当我们使用MyClass创建一个实例时，可以通过访问sum属性来获取a和b属性的和，而无需手动计算它们：

>>> obj = MyClass(1, 2)  
>>> obj.sum  
3

Nach dem Login kopieren

缓存属性值

另一个常见的用途是缓存属性值。使用描述器可以缓存属性值，从而提高程序性能，特别是当属性值是一个较慢的计算或大量数据时。下面是一个缓存属性值的示例代码：

class CachedProperty:  
    def __init__(self, func):  
        self.func = func  
        self.__name__ = func.__name__  
         
    def __get__(self, instance, owner):  
        if instance is None:  
            return self  
        value = self.func(instance)  
        setattr(instance, self.__name__, value)  
        return value  
  
class MyClass:  
    def __init__(self, data):  
        self._data = data  
         
    @CachedProperty  
    def processed_data(self):  
        # Perform some slow computation  
        result = ...  
        return result

Nach dem Login kopieren

在上面的代码中，CachedProperty是一个描述器，它使用__get__()方法来缓存属性值。MyClass是一个包含_data属性的类，它定义了一个processed_data属性，该属性使用@CachedProperty装饰器来实现缓存。当我们访问processed_data属性时，如果缓存中已经存在属性值，则直接返回缓存的值。否则，计算属性值，并将其存储在缓存中。

实现属性访问控制

描述器还可以用于实现属性访问控制。例如，我们可以使用描述器来禁止对一个属性进行修改。下面是一个实现属性访问控制的示例代码：

class ReadOnlyDescriptor:  
    def __init__(self, value):  
        self.value = value  
         
    def __get__(self, instance, owner):  
        return self.value  
     
    def __set__(self, instance, value):  
        raise AttributeError("can&#39;t set attribute")  
  
class MyClass:  
    def __init__(self, data):  
        self._data = ReadOnlyDescriptor(data)

Nach dem Login kopieren

在上面的代码中，ReadOnlyDescriptor是一个描述器，它使用__set__()方法来禁止对属性进行修改。MyClass是一个包含 _data属性的类，它定义了一个只读的属性。当我们尝试对_data属性进行修改时，会引发AttributeError异常。

自定义属性访问控制

除了上面介绍的基本描述器，Python还提供了property装饰器，它可以用于定义自定义的属性访问控制。使用property

Wenn der Python-Interpreter auf die Eigenschaften eines Objekts zugreift, prüft er zunächst, ob es sich bei der Eigenschaft um einen Deskriptor handelt. Wenn das Attribut ein Deskriptor ist, rufen Sie die Methode __get__() auf, um den Attributwert abzurufen. Wenn das Attribut kein Deskriptor ist, wird der Attributwert direkt zurückgegeben. #🎜🎜##🎜🎜#Wenn wir einen Python-Deskriptor verwenden möchten, um das Attributzugriffsverhalten zu steuern, müssen wir __get__(), __set__()</ im Deskriptorprotokoll implementieren mindestens eine der Methoden code> und <code>__delete__(). Im Folgenden finden Sie eine spezifische Beschreibung dieser Methoden: #🎜🎜##🎜🎜#__get__(self,instance,owner): Wird zum Abrufen von Attributwerten verwendet. Wenn es sich bei dem Attribut, auf das zugegriffen wird, um eine Instanz handelt, ist der Instanzparameter das Instanzobjekt und der Eigentümerparameter das Klassenobjekt. Wenn es sich bei dem Attribut, auf das zugegriffen wird, um eine Klasse handelt, ist der Instanzparameter None und der Owner-Parameter das Klassenobjekt. #🎜🎜##🎜🎜#__set__(selbst, Instanz, Wert): wird zum Festlegen von Attributwerten verwendet. Wenn der Attributwert von einer Instanz festgelegt wird, ist der Instanzparameter das Instanzobjekt und der Wertparameter der festzulegende Wert. Wenn der Attributwert von einer Klasse festgelegt wird, ist der Instanzparameter None und der Wertparameter der festzulegende Wert. #🎜🎜##🎜🎜#__delete__(selbst, Instanz): wird zum Löschen von Attributwerten verwendet. Wenn der zu löschende Eigenschaftswert eine Instanz ist, ist der Instanzparameter das Instanzobjekt. Wenn der Eigenschaftswert aus einer Klasse gelöscht wird, ist der Instanzparameter None.
So verwenden Sie Python-Deskriptoren#🎜🎜##🎜🎜#Anwendungsszenarien#🎜🎜##🎜🎜#Python-Deskriptoren können in einer Vielzahl von Situationen verwendet werden, z. B. zum Berechnen von Attributen, zum Zwischenspeichern von Attributwerten und zum Implementieren von Attributen Zugangskontrolle. Hier sind einige Beispiele für die Verwendung von Python-Deskriptoren. #🎜🎜#

Berechnete Eigenschaft

#🎜🎜#Eine berechnete Eigenschaft ist eine Eigenschaft, die aus anderen Eigenschaften berechnet wird. Mithilfe eines Deskriptors können Sie beispielsweise eine berechnete Eigenschaft erstellen, die zwei numerische Eigenschaften hinzufügt. Das Folgende ist ein Beispielcode, der eine berechnete Eigenschaft implementiert: #🎜🎜#

class MyClass:  
    def __init__(self, value):  
        self._value = value  
         
    @property  
    def value(self):  
        return self._value  
     
    @value.setter  
    def value(self, new_value):  
        if new_value < 0:  
            raise ValueError("value must be non-negative")  
        self._value = new_value

Nach dem Login kopieren

#🎜🎜#Im obigen Code ist SumDescriptor ein Deskriptor, der die __get__()-Methode verwendet, um die Summe der a- und b-Attribute zu berechnen. MyClass ist eine Klasse, die die Eigenschaften a und b enthält. Sie definiert auch eine Summeneigenschaft, die eine Instanz von SumDescriptor ist. #🎜🎜##🎜🎜#Wenn wir mit MyClass eine Instanz erstellen, können wir die Summe der a- und b-Attribute erhalten, indem wir auf das Summenattribut zugreifen, ohne sie manuell berechnen zu müssen: #🎜🎜#rrreee

Attributwerte zwischenspeichern #🎜🎜#Eine weitere häufige Verwendung ist das Zwischenspeichern von Attributwerten. Durch die Verwendung von Deskriptoren können Sie Attributwerte zwischenspeichern und so die Programmleistung verbessern, insbesondere wenn es sich bei dem Attributwert um eine langsame Berechnung oder eine große Datenmenge handelt. Hier ist ein Beispielcode zum Zwischenspeichern von Eigenschaftswerten: #🎜🎜#rrreee#🎜🎜#Im obigen Code ist `CachedProperty` ein Deskriptor, der die Methode `get()` zum Zwischenspeichern verwendet Immobilienwerte. `MyClass` ist eine Klasse, die das Attribut `_data` enthält. Sie definiert ein Attribut `processed_data`, das mit dem Server `@CachedProperty` dekoriert ist Caching zu implementieren. Wenn wir auf das Attribut `processed_data` zugreifen und der Attributwert bereits im Cache vorhanden ist, wird der zwischengespeicherte Wert direkt zurückgegeben. Andernfalls wird der Eigenschaftswert berechnet und im Cache gespeichert. #🎜🎜#

Attributzugriffskontrolle implementieren

#🎜🎜#Deskriptoren können auch zum Implementieren der Attributzugriffskontrolle verwendet werden. Beispielsweise können wir Deskriptoren verwenden, um Änderungen an einer Eigenschaft zu deaktivieren. Das Folgende ist ein Beispielcode, der die Attributzugriffskontrolle implementiert: #🎜🎜#rrreee#🎜🎜#Im obigen Code ist ReadOnlyDescriptor ein Deskriptor, der die __set__()</code >Methode verwendet um die Änderung von Eigenschaften zu deaktivieren. <code>MyClass ist eine Klasse, die das Attribut _data enthält, das ein schreibgeschütztes Attribut definiert. Wenn wir versuchen, das Attribut _data zu ändern, wird eine AttributeError-Ausnahme ausgelöst. #🎜🎜#

Zugriffskontrolle für benutzerdefinierte Eigenschaften

#🎜🎜#Zusätzlich zu den oben eingeführten Basisdeskriptoren bietet Python auch den Dekorator property, der zum Definieren benutzerdefinierter Attribute verwendet werden kann Zugangskontrolle. Mit dem property-Dekorator können wir eine Methode in eine schreibgeschützte Eigenschaft, eine beschreibbare Eigenschaft oder eine Lese-/Schreibeigenschaft konvertieren. Das Folgende ist ein Beispielcode für die Zugriffskontrolle für benutzerdefinierte Attribute: #🎜🎜#

class MyClass:  
    def __init__(self, value):  
        self._value = value  
         
    @property  
    def value(self):  
        return self._value  
     
    @value.setter  
    def value(self, new_value):  
        if new_value < 0:  
            raise ValueError("value must be non-negative")  
        self._value = new_value

Nach dem Login kopieren

在上面的代码中，value方法被转换为一个属性。@property装饰器将value方法转换为只读属性，@value.setter装饰器将value方法转换为可写属性。当我们尝试对value属性进行修改时，如果新值小于0，则引发ValueError异常。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Deskriptoren in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!