0Pricing
Python Academy · Leçon

Le décorateur @property

Utilisez property pour créer des accesseurs, des mutateurs et des méthodes de suppression.

Le décorateur @property est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Introduction

@property transforme une méthode en attribut lisible. @setter et @deleter complètent le modèle d’accès contrôlé.

Pourquoi utiliser @property ?

Au lieu de getX()/setX() comme en Java, Python utilise @property. L’accès ressemble à celui d’un attribut : obj.value, et non obj.get_value().
class Circle:
    def __init__(self, r): self._r = r
    @property
    def radius(self): return self._r
c = Circle(5)
print(c.radius)  # no ()

Propriétés calculées

Les méthodes @property effectuent leur calcul à la demande. obj.area est recalculé à chaque accès : aucune valeur stockée n’est nécessaire.
import math
class Circle:
    def __init__(self, r): self._r = r
    @property
    def area(self): return math.pi * self._r**2
c = Circle(5)
print(round(c.area, 2))

Accesseur d’écriture d’une propriété

@property_name.setter ajoute un accesseur d’écriture. Désormais, c.radius = 10 appelle la méthode correspondante.
class Circle:
    def __init__(self, r): self._r = r
    @property
    def radius(self): return self._r
    @radius.setter
    def radius(self, val):
        if val <= 0: raise ValueError('radius must be positive')
        self._r = val
c = Circle(5)
c.radius = 10
print(c.radius)

Suppression d’une propriété

@property_name.deleter gère del obj.attr. Utilisez-le pour la logique de nettoyage.
class User:
    def __init__(self, name): self._name = name
    @property
    def name(self): return self._name
    @name.deleter
    def name(self): del self._name
u = User('Alice')
del u.name
print(hasattr(u, '_name'))

Propriété en lecture seule

Définissez uniquement l’accesseur de lecture, sans accesseur d’écriture. Toute tentative d’affectation lève AttributeError.
class Const:
    def __init__(self, v): self._v = v
    @property
    def value(self): return self._v
c = Const(42)
print(c.value)
try: c.value = 99
except AttributeError as e: print(e)

Propriété avec validation

Les accesseurs d’écriture sont l’endroit idéal pour valider les données : vérifiez le type, l’intervalle ou le format avant de les stocker.
class BoundedInt:
    def __init__(self, lo, hi): self.lo,self.hi=lo,hi; self._v=lo
    @property
    def value(self): return self._v
    @value.setter
    def value(self, v):
        if not self.lo <= v <= self.hi:
            raise ValueError(f'{v} out of [{self.lo},{self.hi}]')
        self._v = v
b = BoundedInt(0, 10)
b.value = 5
print(b.value)

Mise en cache avec property

Combinez @property avec une valeur mise en cache pour effectuer le calcul une seule fois et mémoriser le résultat.
class Expensive:
    _cache = None
    @property
    def result(self):
        if self._cache is None:
            self._cache = sum(range(1000))
        return self._cache
e = Expensive()
print(e.result)
print(e.result)

cached_property (Python 3.8 et versions ultérieures)

@functools.cached_property calcule la propriété une fois et la stocke comme attribut d’instance, sans calcul répété.
from functools import cached_property
import math
class Circle:
    def __init__(self, r): self.r = r
    @cached_property
    def area(self): return math.pi * self.r**2
c = Circle(5)
print(round(c.area, 2))

Propriété et __slots__

__slots__ empêche la création d’attributs arbitraires et économise de la mémoire. Les propriétés ajoutent de la logique. Elles sont complémentaires.
class Point:
    __slots__ = ('_x', '_y')
    def __init__(self, x, y): self._x,self._y=x,y
    @property
    def x(self): return self._x
p = Point(1, 2)
print(p.x)

Quand utiliser @property

Utilisez @property lorsque vous avez besoin d’une validation, de valeurs calculées ou de préserver la compatibilité avec les versions précédentes tout en modifiant l’implémentation interne.
# Before: class Person:
#     def __init__(self, age): self.age = age
# After: add validation without changing caller code
class Person:
    def __init__(self, age): self.age = age
    @property
    def age(self): return self._age
    @age.setter
    def age(self, v):
        if v < 0: raise ValueError('negative age')
        self._age = v
p = Person(30)
print(p.age)

Vérification rapide

Que se passe-t-il lorsque vous essayez d’affecter une valeur à une @property en lecture seule, sans accesseur d’écriture défini ?

Récapitulatif

@property : l’accesseur de lecture devient un accès d’attribut. @name.setter ajoute la possibilité d’écrire. @name.deleter ajoute la possibilité de supprimer. @cached_property calcule une seule fois. Les accesseurs d’écriture servent à la validation.

Continuez

Vos progrès sont excellents ! Continuez pour maîtriser le prochain concept.

Questions Fréquemment Posées

La leçon « Le décorateur @property » est-elle gratuite ?

Oui — le texte complet de « Le décorateur @property » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Le décorateur @property » ?

Utilisez property pour créer des accesseurs, des mutateurs et des méthodes de suppression. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Le décorateur @property » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Les fonctions comme objets de première classe
  2. Écrire des décorateurs personnalisés
  3. Le décorateur @property
  4. @classmethod et @staticmethod
← Retour à Python Academy