Un type de décorateurs est celui des getters et setters de propriétés. Ces décorateurs permettent un accès contrôlé aux variables dans les instances de classe.

Les getters et setters de propriétés sont conçus spécifiquement pour le contrôle des attributs dans la programmation orientée objet. Ceux-ci sont différents des décorateurs de fonctions dans la mesure où ils sont utilisés pour les attributs de classe (consultez mon article sur les décorateurs de fonctions ici).

Les décorateurs de fonctions et les décorateurs getter et setter de propriétés modifient le code avec du code réutilisable et utilisent la syntaxe '@'. Ils modifient tous les deux la fonctionnalité du code.

D'accord, allons-y.

Les getters et setters de propriétés sont appliqués aux méthodes au sein d'une classe pour définir divers comportements. Un setter définit l'attribut sur une valeur, et un getter récupère un attribut d'une classe. L'attribut est set en premier.

Prenons un exemple, puis nous le décomposerons :

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

Passons en revue une partie de ce code :

Les traits de soulignement placés devant certains attributs (condition, taille) indiquent au développeur qu'ils sont privés ; ils sont spécifiques à chaque instance de la classe Shoe (chaque chaussure, en minuscule).

Vous remarquerez peut-être que la condition et la taille sont instanciées différemment. self._condition = "New" signifie que chaque instance (ou objet) de la classe shoe est instanciée avec une condition "New". La même chose est faite pour l'attribut size, mais il n'est pas écrit comme self._size = 9 afin de déclencher la validation de la propriété setter, car size doit être un entier (c'est un processus appelé validation). Nous définissons directement la condition de chaque objet chaussure, au lieu de l'exécuter via les méthodes de définition de propriétés et de lecture.

La méthode Cobble n'a pas besoin de décorateur car elle effectue simplement une action, sans obtenir/définir un attribut de chaque objet chaussure.

Apportons une dernière modification à notre code. Par exemple, que se passe-t-il si nous voulons nous assurer que l’attribut size ne peut pas être modifié ultérieurement ? Après tout, une chaussure ne change pas vraiment de taille, n'est-ce pas ?

Nous pouvons utiliser la fonction hasattr() pour effectuer une vérification sur chaque objet chaussure. Possède-t-il un attribut privé de taille, indiqué par la présence de « _size » ? Si tel est le cas, il ne peut pas être modifié. Voici le code implémenté :

 @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")

Les setters et getters de propriétés sont un peu difficiles à comprendre, mais une fois compris, vous coderez Python comme un pro !

Sources :

Matériel scolaire Flatiron