Quelle est la pythonic façon d'utiliser les accesseurs et mutateurs?

Quelle est la pythonic façon d'utiliser les accesseurs et mutateurs?

La "Pythonic" moyen est pas à utiliser des "getters" et des "poseurs", mais utiliser simplement les attributs, tels que la question démontre, et del de déréférencement (mais les noms sont changés pour protéger les innocents... les builtins):

value = 'something'

obj.attribute = value  
value = obj.attribute
del obj.attribute

Si plus tard, vous souhaitez modifier le paramètre et d'obtenir, vous pouvez le faire sans avoir à modifier le code de l'utilisateur, à l'aide de la property décorateur:

class Obj:
    """property demo"""
    #
    @property
    def attribute(self): # implements the get - this name is *the* name
        return self._attribute
    #
    @attribute.setter
    def attribute(self, value): # name must be the same
        self._attribute = value
    #
    @attribute.deleter
    def attribute(self): # again, name must be the same
        del self._attribute

(Décorateur, des copies et des mises à jour de l'état de la propriété de l'objet, donc, la note que vous devriez probablement utiliser le même nom pour chaque ensemble, obtenir et de supprimer la fonction/méthode.)

Après la définition ci-dessus, le réglage d'origine, et de la suppression est la même:

obj = Obj()
obj.attribute = value  
the_value = obj.attribute
del obj.attribute

Vous devriez éviter cela:

def set_property(property,value):  
def get_property(property):  

Tout d'abord, le ci-dessus ne fonctionne pas, parce que vous ne fournissez pas un argument pour l'instance que la propriété pourrait être fixée (généralement self), qui serait:

class Obj:

    def set_property(self, property, value): # don't do this
        ...
    def get_property(self, property):        # don't do this either
        ...

Deuxièmement, cela duplique l'objet de deux méthodes spéciales, __setattr__ et __getattr__.

Troisièmement, nous avons aussi la setattr et getattr fonctions internes.

    setattr(object, 'property_name', value)
    getattr(object, 'property_name', default_value)  # default is optional

La @property décorateur pour créer des accesseurs et mutateurs.

Par exemple, nous pourrions modifier le comportement du paramètre d'imposer des restrictions à la valeur définie:

    class Protective(object):

        @property
        def protected_value(self):
            return self._protected_value

        @protected_value.setter
        def protected_value(self, value):
            if acceptable(value): # e.g. type or range check
                self._protected_value = value

En général, nous voulons éviter d'utiliser property et il suffit d'utiliser directement les attributs.

C'est ce qui est attendu par les utilisateurs de Python. Suivant la règle de moindre surprise, vous devriez essayer de donner aux utilisateurs ce qu'ils attendent à moins d'avoir un très convaincante du contraire.

Démonstration

Par exemple, disons que nous avons besoin de notre objet attribut protégé pour être un entier compris entre 0 et 100 inclus, et d'empêcher sa suppression, avec les messages appropriés pour informer l'utilisateur de son utilisation correcte:

class Protective(object):
    def __init__(self, start_protected_value=0):
        self.protected_value = start_protected_value
    @property
    def protected_value(self):
        return self._protected_value
    @protected_value.setter
    def protected_value(self, value):
        if value != int(value):
            raise TypeError("protected_value must be an integer")
        if 0 <= value <= 100:
            self._protected_value = int(value)
        else:
            raise ValueError("protected_value must be " +
                             "between 0 and 100 inclusive")
    @protected_value.deleter
    def protected_value(self):
        raise AttributeError("do not delete, protected_value can be set to 0")

Et utilisation:

>>> p1 = Protective(3)
>>> p1.protected_value
3
>>> p1 = Protective(5.0)
>>> p1.protected_value
5
>>> p2 = Protective(-5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
  File "<stdin>", line 15, in protected_value
ValueError: protectected_value must be between 0 and 100 inclusive
>>> p1.protected_value = 7.3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 17, in protected_value
TypeError: protected_value must be an integer
>>> p1.protected_value = 101
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 15, in protected_value
ValueError: protectected_value must be between 0 and 100 inclusive
>>> del p1.protected_value
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 18, in protected_value
AttributeError: do not delete, protected_value can be set to 0

Les noms de matière?

Oui ils ne. .setter et .deleter faire des copies de l'original de la propriété. Cela permet à les sous-classes pour bien modifier le comportement sans en altérer le comportement de la mère.

class Obj:
    """property demo"""
    #
    @property
    def get_only(self):
        return self._attribute
    #
    @get_only.setter
    def get_or_set(self, value):
        self._attribute = value
    #
    @get_or_set.deleter
    def get_set_or_delete(self):
        del self._attribute

Maintenant pour que cela fonctionne, vous devez utiliser les noms respectifs:

obj = Obj()
# obj.get_only = 'value' # would error
obj.get_or_set = 'value'  
obj.get_set_or_delete = 'new value'
the_value = obj.get_only
del obj.get_set_or_delete
# del obj.get_or_set # would error

Je ne suis pas sûr de l'endroit où ce serait utile, mais les cas d'utilisation est si vous voulez un get, set, et/ou de supprimer seule propriété. Probablement préférable de s'en tenir à la sémantique même de la propriété portant le même nom.

Conclusion

Commencer avec de simples attributs.

Si plus tard vous avez besoin de fonctionnalités autour de la mise en, arriver, et la suppression, vous pouvez l'ajouter avec la propriété décorateur.

Éviter des fonctions nommé set_... et get_... - c'est ce que les propriétés sont pour.

Découvrez la @property décorateur.

Vous pouvez utiliser les accesseurs/mutateurs (c'est à dire @attr.setter et @property) ou pas, mais la chose la plus importante est pour être cohérent!

PEP8, La conception de l'Héritage dit:

Pour de simples données publiques attributs, il est mieux pour exposer simplement le nom de l'attribut, sans complexe accesseur/mutateur méthodes. Gardez à l'esprit que Python fournit une voie d'accès facile à la mise en valeur future, si vous trouvez qu'un simple attribut de données a besoin pour grandir comportement fonctionnel. Dans ce cas, utilisez les propriétés de cacher fonctionnel de mise en œuvre de derrière de données simple attribut de la syntaxe d'accès.

D'autre part, selon Google Guide de Style Python Les Règles De La Langue/Propriétés la recommandation est de:

Utiliser les propriétés dans le nouveau code d'accès ou un ensemble de données où vous auriez normalement utilisé simple, léger accesseur de la ou des méthodes de définition. Les propriétés doivent être créées avec le @property décorateur.

Les avantages de cette approche:

La lisibilité est augmenté par l'élimination explicite obtenir et définir les appels de méthode pour attribut simple d'accès. Permet des calculs d'être paresseux. Considéré comme le Pythonic moyen de maintenir l'interface d'une classe. En termes de performance, permettant propriétés contourne besoin trivial méthodes d'accès lorsqu'une variable directe d'accès est raisonnable. Cela permet également de méthodes accesseur pour être ajoutées dans le futur sans rupture de l'interface.

et des inconvénients:

Doit hériter de object en Python 2. Peut masquer les effets secondaires comme la surcharge d'opérateur. Peut être source de confusion pour les sous-classes.