Eine Art von Dekorateuren sind Property Getter und Setter. Diese Dekoratoren ermöglichen den kontrollierten Zugriff auf Variablen in Klasseninstanzen.

Property Getter und Setter sind speziell für die Steuerung von Attributen in der objektorientierten Programmierung konzipiert. Diese unterscheiden sich von Funktionsdekoratoren darin, dass sie für Klassenattribute verwendet werden (sehen Sie sich hier meinen Beitrag zu Funktionsdekoratoren an).

Sowohl Funktionsdekoratoren als auch Eigenschaften-Getter- und Setter-Dekoratoren ändern Code mit wiederverwendbarem Code und verwenden die „@“-Syntax. Beide ändern die Funktionalität des Codes.

Okay, fangen wir an.

Eigenschafts-Getter und -Setter werden auf Methoden innerhalb einer Klasse angewendet, um verschiedene Verhaltensweisen zu definieren. Ein Setter setzt das Attribut auf einen Wert und ein Getter greift ein Attribut aus einer Klasse. Das Attribut wird zuerst set gesetzt.

Sehen wir uns ein Beispiel an und schlüsseln es dann auf:

class Shoe:
    def __init__(self, brand = "Adidas", size = 9):
        self.brand = brand
        self.size = size
        self._condition = "New"

    @property
    def size(self):
        """The size property"""
        return self._size

    @size.setter
    def size(self, size):
        """size must be an integer"""
        if isinstance(size, int):
            self._size = size
        else:
            print("size must be an integer")

    def cobble(self):
        """Repairs the shoe and sets the condition to 'New'."""
        self.condition = "New"
        print("Your shoe is as good as new!")

    @property
    def condition(self):
        """The condition property"""
        return self._condition

    @condition.setter
    def condition(self, condition):
        self._condition = condition

Lassen Sie uns einen Teil dieses Codes durchgehen:

Die Unterstriche vor einigen Attributen (Bedingung, Größe) zeigen dem Entwickler an, dass sie privat sind; Sie sind spezifisch für jede Instanz der Shoe-Klasse (jeder Schuh, Kleinbuchstabe).

Möglicherweise stellen Sie fest, dass Bedingung und Größe unterschiedlich instanziiert werden. self._condition = „New“ bedeutet, dass jede Instanz (oder jedes Objekt) der Schuhklasse mit der Bedingung „New“ instanziiert wird. Das Gleiche gilt für das Größenattribut, es wird jedoch nicht als self._size = 9 geschrieben, sodass es die Validierung der Setter-Eigenschaft auslöst, da die Größe eine Ganzzahl sein muss (dies ist ein Prozess, der als Validierung bezeichnet wird). Wir legen den Zustand jedes einzelnen Schuhobjekts direkt fest, anstatt ihn über die Property-Setter- und Getter-Methoden laufen zu lassen.

Die Cobble-Methode benötigt keinen Dekorator, da sie lediglich eine Aktion ausführt und kein Attribut jedes Schuhobjekts abruft/festlegt.

Lassen Sie uns eine letzte Änderung an unserem Code vornehmen. Was ist beispielsweise, wenn wir sicherstellen möchten, dass das Größenattribut später nicht geändert werden kann? Ein Schuh verändert schließlich doch nicht wirklich seine Größe, oder?

Wir können die Funktion hasattr() verwenden, um eine Prüfung für jedes Schuhobjekt durchzuführen. Verfügt es über ein privates Größenattribut, das durch das Vorhandensein von „_size“ angezeigt wird? Wenn ja, kann es nicht geändert werden. Hier ist der implementierte Code:

 @size.setter
    def size(self, size):
        """size must be an integer and can't be changed once set"""
        if hasattr(self, '_size'):
            raise AttributeError("Can't change size once set")
        if isinstance(size, int):
            self._size = size
        else:
            raise ValueError("size must be an integer")

Property-Setter und Getter sind etwas schwierig zu verstehen, aber sobald Sie es verstanden haben, werden Sie Python wie ein Profi programmieren!

Quellen:

Flatiron-Schulmaterial