Question Comment fonctionne le décorateur @property?

La documentation dit C'est juste un raccourci pour créer des propriétés en lecture seule. Alors

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

est équivalent à

def getx(self):
    return self._x
x = property(getx)

La première partie est simple:

@property
def x(self): ...

est le même que

def x(self): ...
x = property(x)

• qui, à son tour, est la syntaxe simplifiée pour créer un property avec juste un getter.

L'étape suivante consisterait à étendre cette propriété avec un setter et un deleter. Et cela arrive avec les méthodes appropriées:

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

retourne une nouvelle propriété qui hérite tout de l'ancien x plus le setter donné.

x.deleter fonctionne de la même manière.

Voici un exemple minimal de comment @property peut être implémenté:

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

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

Autrement 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 le même 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 le même 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 le même 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)

Ce 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 messages ici et réalisé que nous pourrions avoir besoin d'un exemple réel, Pourquoi, en fait, nous avons @property? Donc, considérez une application Flask où vous utilisez un système d'authentification. Vous déclarez un utilisateur modèle 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 l'attribut "caché" passworden utilisant @property ce qui déclenche AttributeError assertion lorsque vous essayez d'y accéder directement, alors que nous avons utilisé @ property.setter pour définir la variable d'instance réelle password_hash.

Maintenant en 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()
...

Attribut de notification password cela vient d'un formulaire d'inscription lorsqu'un utilisateur remplit le formulaire. La confirmation du mot de passe se produit à l'avant avec EqualTo('password', message='Passwords must match') (dans le cas où vous vous poseriez la question, mais c'est un sujet différent lié aux formes Flask).

J'espère que cet exemple sera utile

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

• Création du getter, mise en place de méthodes pour un attribut puis passage de celles-ci en tant qu'argument à propriété fonction
• En utilisant le @propriété décorateur.

Vous pouvez jeter un oeil à quelques exemples sur lesquels j'ai écrit propriétés en python.