Comment les @property décorateur de travail?

La property() fonction renvoie un spécial descripteur de l'objet:

>>> property()
<property object at 0x10ff07940>

C'est cet objet qui a supplémentaire méthodes:

>>> property().getter
<built-in method getter of property object at 0x10ff07998>
>>> property().setter
<built-in method setter of property object at 0x10ff07940>
>>> property().deleter
<built-in method deleter of property object at 0x10ff07998>

Ceux-ci agissent comme des décorateurs trop. Ils reviennent une nouvelle propriété de l'objet:

>>> property().getter(None)
<property object at 0x10ff079f0>

qui est une copie de l'objet ancien, mais avec l'une des fonctions remplacé.

N'oubliez pas que le @decorator syntaxe est juste sucre syntaxique; la syntaxe:

@property
def foo(self): return self._foo

vraiment signifie la même chose que

def foo(self): return self._foo
foo = property(foo)

donc foo la fonction est remplacé par property(foo), qui nous l'avons vu ci-dessus est un objet spécial. Ensuite, lorsque vous utilisez @foo.setter(), ce que vous faites, c'est l'appel que property().setter méthode que je vous ai montré ci-dessus, qui renvoie une nouvelle copie de la propriété, mais cette fois avec le setter remplacé par le décoré de la méthode.

La séquence suivante crée également un plein sur la propriété, à l'aide de ces décorateur méthodes.

- Nous d'abord de créer des fonctions et une property objet avec juste un getter:

>>> def getter(self): print 'Get!'
... 
>>> def setter(self, value): print 'Set to {!r}!'.format(value)
... 
>>> def deleter(self): print 'Delete!'
... 
>>> prop = property(getter)
>>> prop.fget is getter
True
>>> prop.fset is None
True
>>> prop.fdel is None
True

Ensuite, nous utilisons la .setter() méthode pour ajouter un setter:

>>> prop = prop.setter(setter)
>>> prop.fget is getter
True
>>> prop.fset is setter
True
>>> prop.fdel is None
True

Dernière, nous avons ajouter un deleter avec le .deleter() méthode:

>>> prop = prop.deleter(deleter)
>>> prop.fget is getter
True
>>> prop.fset is setter
True
>>> prop.fdel is deleter
True

Dernier mais non le moins, la property objet agit comme un descripteur de l'objet, de sorte qu'il a .__obtenez__(), .__définissez__() et .__supprimer__() méthodes de raccordement dans l'instance de l'attribut de l'obtention, de réglage et de suppression:

>>> class Foo(object): pass
... 
>>> prop.__get__(Foo(), Foo)
Get!
>>> prop.__set__(Foo(), 'bar')
Set to 'bar'!
>>> prop.__delete__(Foo())
Delete!

Le Descripteur Howto comprend un pur python exemple de mise en œuvre de la property() type:

class Property(object):
    "Emulate PyProperty_Type() in Objects/descrobject.c"

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)

Voici un exemple minimal de la façon dont @property peuvent être mises en œuvre:

class Thing:
    def __init__(self, my_word):
        self._word = my_word 
    @property
    def word(self):
        return self._word

>>> print( Thing('ok').word )
'ok'

Sinon word reste une méthode au lieu d'une propriété.

class Thing:
    def __init__(self, my_word):
        self._word = my_word
    def word(self):
        return self._word

>>> print( Thing('ok').word() )
'ok'

Ce qui suit:

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Est la même chose que:

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x

    def _x_set(self, value):
        self._x = value

    def _x_del(self):
        del self._x

    x = property(_x_get, _x_set, _x_del, 
                    "I'm the 'x' property.")

Est la même chose que:

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x

    def _x_set(self, value):
        self._x = value

    def _x_del(self):
        del self._x

    x = property(_x_get, doc="I'm the 'x' property.")
    x = x.setter(_x_set)
    x = x.deleter(_x_del)

Est la même chose que:

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x
    x = property(_x_get, doc="I'm the 'x' property.")

    def _x_set(self, value):
        self._x = value
    x = x.setter(_x_set)

    def _x_del(self):
        del self._x
    x = x.deleter(_x_del)

Qui est le même que :

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

J'ai lu tous les posts ici et réalisé que nous avons peut-être besoin d'un exemple réel, Pourquoi, en fait, nous avons @property?
Donc, envisager un Flacon d'application lorsque vous utilisez le système d'authentification.
Vous déclarez un modèle de l'Utilisateur dans models.py:

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(64), unique=True, index=True)
    username = db.Column(db.String(64), unique=True, index=True)
    password_hash = db.Column(db.String(128))

    ...

    @property
    def password(self):
        raise AttributeError('password is not a readable attribute')

    @password.setter
    def password(self, password):
        self.password_hash = generate_password_hash(password)

    def verify_password(self, password):
        return check_password_hash(self.password_hash, password)

Dans ce code, nous avons un attribut "caché" password en utilisant @property qui déclenche AttributeError assertion lorsque vous essayez d'y accéder directement, tandis que nous avons utilisé @property.setter pour définir la véritable variable d'instance password_hash.

Maintenant dans auth/views.py nous pouvons instancier un Utilisateur avec:

...
@auth.route('/register', methods=['GET', 'POST'])
def register():
    form = RegisterForm()
    if form.validate_on_submit():
        user = User(email=form.email.data,
                    username=form.username.data,
                    password=form.password.data)
        db.session.add(user)
        db.session.commit()
...

Avis attribut password qui vient d'un formulaire d'inscription lorsqu'un utilisateur remplit le formulaire. Confirmation du mot de passe qui se passe sur le front-end avec EqualTo('password', message='Passwords must match') (dans le cas où si vous vous demandez, mais c'est un autre sujet lié Flacon de formes).

J'espère que cet exemple sera utile

Nous allons commencer avec Python décorateurs.

Un Python décorateur est une fonction qui permet d'ajouter des fonctionnalités supplémentaires à un cadre déjà défini la fonction.

En Python, tout est objet En Python, tout est objet. Les fonctions en Python sont des objets de première classe qui signifie qu'ils peuvent être référencé par une variable, ajoutés dans les listes, passées en argument à une autre fonction, etc.

Envisager l'extrait de code suivant.

def decorator_func(fun):
    def wrapper_func():
        print("Wrapper function started")
        fun()
        print("Given function decorated")
        # Wrapper function add something to the passed function and decorator 
        # returns the wrapper function
    return wrapper_func

def say_bye():
    print("bye!!")

say_bye = decorator_func(say_bye)
say_bye()

# Output:
#  Wrapper function started
#  bye
#  Given function decorated

Ici, nous pouvons dire que la fonction décorateur modifié notre dit_bonjour fonction et l'ajout de quelques lignes de code supplémentaires en elle.

La syntaxe de Python pour décorateur

def decorator_func(fun):
    def wrapper_func():
        print("Wrapper function started")
        fun()
        print("Given function decorated")
        # Wrapper function add something to the passed function and decorator 
        # returns the wrapper function
    return wrapper_func

@decorator_func
def say_bye():
    print("bye!!")

say_bye()

Nous allons Conclure de tout ce que avec un scénario, mais avant cela, parlons un peu de la oups principes.

Getters et les setters sont utilisés dans de nombreux langages de programmation orientée objet afin de garantir le principe d'encapsulation des données(est considéré comme le regroupement de données avec les méthodes qui fonctionnent sur ces données.)

Ces méthodes sont bien sûr de la lecture pour la récupération des données et la définition pour changer les données.

Selon ce principe, les attributs d'une classe sont privés de cacher et de protéger de l'autre code.

Yup, @property est fondamentalement un pythonic façon d'utiliser les accesseurs et mutateurs.

Python est un grand concept de propriété qui rend la vie d'un objet-orienté programmeur beaucoup plus simple.

Supposons que vous décidez de faire une classe qui peut stocker la température en degré Celsius.

class Celsius:
def __init__(self, temperature = 0):
    self.set_temperature(temperature)

def to_fahrenheit(self):
    return (self.get_temperature() * 1.8) + 32

def get_temperature(self):
    return self._temperature

def set_temperature(self, value):
    if value < -273:
        raise ValueError("Temperature below -273 is not possible")
    self._temperature = value

Refonte du Code, Voici comment nous avons pu obtenir cela avec la propriété.

En Python, la propriété() est une fonction intégrée qui crée et retourne un objet de propriété.

Un objet de propriété a trois méthodes getter(), setter () et delete().

class Celsius:
def __init__(self, temperature = 0):
    self.temperature = temperature

def to_fahrenheit(self):
    return (self.temperature * 1.8) + 32

def get_temperature(self):
    print("Getting value")
    return self.temperature

def set_temperature(self, value):
    if value < -273:
        raise ValueError("Temperature below -273 is not possible")
    print("Setting value")
    self.temperature = value

temperature = property(get_temperature,set_temperature)

Ici,

temperature = property(get_temperature,set_temperature)

pourrait avoir été ventilés comme,

# make empty property
temperature = property()
# assign fget
temperature = temperature.getter(get_temperature)
# assign fset
temperature = temperature.setter(set_temperature)

Point À Noter:

• get_temperature reste une propriété au lieu d'une méthode.

Vous pouvez maintenant accéder à la valeur de la température par écrit.

C = Celsius()
C.temperature
# instead of writing C.get_temperature()

Nous pouvons aller plus loin et de ne pas définir des noms get_temperature et set_temperature comme elles sont inutiles, et de polluer l'espace de noms de la classe.

La pythonic façon pour traiter le problème ci-dessus est d'utiliser @property.

class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32

    @property
    def temperature(self):
        print("Getting value")
        return self.temperature

    @temperature.setter
    def temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self.temperature = value

Points à Noter -

1. Une méthode qui est utilisée pour obtenir une valeur est décoré avec "@property".
2. La méthode qui a pour fonction que le setter est décoré avec "@la température.setter", Si la fonction a été appelée "x", nous aurions à le décorer avec "@x.setter".
3. Nous avons écrit "deux" méthodes avec le même nom et un nombre différent de paramètres "def température(auto)" et "def température(self,x)".

Comme vous pouvez le voir, le code est nettement moins élégant.

Maintenant,nous allons parler de la vie réelle pratique scenerio.

Disons que vous avez conçu une classe comme suit:

class OurClass:

    def __init__(self, a):
        self.x = a


y = OurClass(10)
print(y.x)

Maintenant, laissez-nous supposons que nos élèves se sont populaires parmi les clients et ils ont commencé à l'utiliser dans leurs programmes, Ils ont fait toutes sortes de missions à l'objet.

Et Un jour fatidique, un fidèle client est venu vers nous et a suggéré que "x" doit être une valeur comprise entre 0 et 1000, c'est vraiment une horrible scénario!

En raison de ces propriétés, il est facile: Nous créons une propriété de la version de "x".

class OurClass:

    def __init__(self,x):
        self.x = x

    @property
    def x(self):
        return self.__x

    @x.setter
    def x(self, x):
        if x < 0:
            self.__x = 0
        elif x > 1000:
            self.__x = 1000
        else:
            self.__x = x

C'est formidable, n'est-ce pas: Vous pouvez commencer par les plus simples de mise en œuvre possibles et imaginables et vous êtes libre de migrer plus tard à une propriété de la version sans avoir à changer l'interface! Ainsi les propriétés ne sont pas juste un remplacement pour les méthodes de lecture et de définition!

Vous pouvez le vérifier la mise en Œuvre ici

Une propriété peut être déclarée dans deux façons.

• De la création de la getter, setter pour un attribut, puis en le passant comme argument pour propriété fonction
• À l'aide de la @property décorateur.

Vous pouvez jeter un oeil à quelques exemples que j'ai écrit au sujet de propriétés en python.

Une remarque:
pour moi, pour Python 2.x, @property ne fonctionne pas comme annoncé quand je n'ai pas hériter de object:

class A():
pass

mais sur le lieu de travail:

class A(object):
pass

pour Python 3, travaillait toujours.