Les descripteurs & property : self.x qui exécute du code Descriptors & property: self.x that runs code

Le numéro précédent s'arrêtait à un __dict__ qui répond. Mais certains objets trouvés dans un __dict__ de classe ne sont pas des valeurs à retourner : ce sont des descripteurs, qui définissent __get__ et __set__, et transforment un accès en apparence anodin — self.x — en appel de méthode. property en est l'exemple le plus courant ; et un descripteur de donnée passe même avant le __dict__ de l'instance. The previous issue stopped once a __dict__ answered. But some objects found in a class __dict__ aren't values to return: they're descriptors, defining __get__ and __set__, turning an access that looks utterly plain — self.x — into a method call. property is the most common example; and a data descriptor even outranks the instance's own __dict__.

Audience
Dev qui a écrit @property et ne comprend pas pourquoi elle passe avant self.__dict__ Dev who's written @property and doesn't understand why it outranks self.__dict__
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

Descripteursproperty__get__

SommaireContents ·
№ 01CadrageFraming3 min

Le numéro précédent s'arrêtait dès qu'un __dict__ répondait. Certaines réponses ne sont pas des valeurs — ce sont du code.The previous issue stopped as soon as a __dict__ answered. Some answers aren't values — they're code.

Le numéro 16 a réduit obj.x à une recherche dans des __dict__ successifs, qui s'arrête à la première correspondance et la retourne telle quelle. C'est vrai pour un entier, une chaîne, une liste. Ce ne l'est plus si ce qui est trouvé dans le __dict__ de la classe définit une méthode spéciale __get__ : Python n'en retourne alors pas la valeur brute, il l'appelle, et retourne ce que cet appel produit. Un tel objet est un descripteur. property, la façon la plus courante d'en créer un, transforme ainsi un accès qui ressemble à une simple lecture — c.aire — en exécution de code à chaque fois qu'on le lit.Issue 16 reduced obj.x to a search through successive __dict__s, stopping at the first match and returning it as-is. That's true for an int, a string, a list. It stops being true if what's found in the class's __dict__ defines a special method __get__: Python then doesn't return its raw value, it calls it, and returns whatever that call produces. Such an object is a descriptor. property, the most common way to create one, thus turns an access that looks like a plain read — c.aire — into code execution, every single time it's read.

c.aire ressemble à un attribut ; c'est un appel de méthodec.aire looks like an attribute; it's a method call
class Cercle:
    def __init__(self, rayon):
        self.rayon = rayon

    @property
    def aire(self):
        print("calcul de l'aire...")   # une preuve que du CODE s'exécute
        return 3.14159 * self.rayon ** 2

c = Cercle(5)
print(c.aire)     # "calcul de l'aire..." puis 78.53975
# c.aire ressemble à un attribut ordinaire -- mais c'est un APPEL DÉGUISÉ
Le sous-réflexe du numéroThis issue's sub-reflex

Face à un self.x qui semble anodin, demande : ce nom vit-il comme une simple valeur dans un __dict__, ou comme un objet qui définit __get__ — et donc s'exécute à chaque lecture ?Facing a self.x that looks harmless, ask: does this name live as a plain value in a __dict__, or as an object that defines __get__ — and therefore runs on every read?

Le même geste qu'au numéro 08The same move as issue 08

len(x) n'est qu'un appel déguisé à x.__len__() — les dunders du numéro 08 reposaient déjà sur cette idée : une syntaxe banale qui cache un appel de méthode spécial. Les descripteurs appliquent exactement le même principe à l'accès attribut lui-même.len(x) is just disguised syntax for x.__len__() — issue 08's dunders already rested on that idea: ordinary syntax hiding a special method call. Descriptors apply the exact same principle to attribute access itself.

№ 02La surpriseThe surprise4 min

Une property passe avant le __dict__ de l'instance — l'exact inverse de ce qu'a établi le numéro 16.A property outranks the instance's __dict__ — the exact opposite of what issue 16 established.

Le numéro 16 a posé une règle simple : l'instance d'abord, la classe ensuite, en dernier recours. Cette règle tient pour les valeurs ordinaires. Elle s'inverse pour un descripteur de donnée — un objet qui définit à la fois __get__ et __set__, ce que fait property. Même en forçant une entrée du même nom dans le __dict__ de l'instance, l'accès continue de passer par le getter de la property, comme si le __dict__ de l'instance n'existait pas pour cet attribut précis.Issue 16 laid out a simple rule: instance first, class as a last resort. That rule holds for ordinary values. It flips for a data descriptor — an object defining both __get__ and __set__, which is exactly what property does. Even forcing an entry of the same name into the instance's __dict__, the access still goes through the property's getter, as if the instance's __dict__ didn't exist for that specific attribute.

Pour une valeur ordinaire : l'instance gagneFor an ordinary value: the instance wins
# Rappel du numéro 16 : "l'instance passe AVANT la classe"
class Joueur:
    vie = 100

j = Joueur()
j.__dict__['vie'] = 50    # on force une entrée dans le __dict__ de l'instance
print(j.vie)              # 50 -- l'instance l'emporte bien sur la classe, comme prévu

Le chapitre 3 explique pourquoi : la recherche réelle de __getattribute__ vérifie d'abord si la classe possède un descripteur de donnée pour ce nom — avant même de regarder le __dict__ de l'instance.Chapter 3 explains why: the real __getattribute__ search first checks whether the class owns a data descriptor for that name — before even looking at the instance's __dict__.

№ 03La mécaniqueThe mechanics5 min

Un descripteur de donnée est vérifié avant tout le reste — même avant le __dict__ de l'instance.A data descriptor is checked before everything else — even before the instance's __dict__.

Un descripteur est un objet qui définit __get__ (lecture) et, optionnellement, __set__ (écriture). S'il définit les deux, c'est un descripteur de donnée, et l'algorithme réel de recherche d'attribut lui donne la priorité absolue, avant même de regarder le __dict__ de l'instance — ce qui explique la surprise du chapitre 2. S'il ne définit que __get__, c'est un descripteur non-donnée (le cas des méthodes ordinaires), et l'instance retrouve alors sa priorité habituelle. property n'est qu'une façon compacte de construire ce trio __get__/__set__/__set_name__ à partir de fonctions décorées.A descriptor is an object defining __get__ (read) and, optionally, __set__ (write). If it defines both, it's a data descriptor, and the real attribute-lookup algorithm gives it absolute priority, even before looking at the instance's __dict__ — which explains chapter 2's surprise. If it only defines __get__, it's a non-data descriptor (the case for ordinary methods), and the instance regains its usual priority. property is just a compact way to build that __get__/__set__/__set_name__ trio from decorated functions.

Un descripteur de donnée écrit à la main — property n'est qu'un raccourci pour çaA hand-written data descriptor — property is just shorthand for this
class Positif:
    def __set_name__(self, proprietaire, nom):
        self.nom_prive = "_" + nom

    def __get__(self, instance, proprietaire):
        if instance is None:
            return self
        return getattr(instance, self.nom_prive)

    def __set__(self, instance, valeur):
        if valeur < 0:
            raise ValueError(f"{self.nom_prive} doit être positif")
        setattr(instance, self.nom_prive, valeur)

class Compte:
    solde = Positif()          # un descripteur DE DONNÉE, écrit à la main

c = Compte()
c.solde = 100        # appelle Positif.__set__(c, 100)
print(c.solde)        # appelle Positif.__get__(c, Compte) -> 100
c.solde = -5          # ValueError -- __set__ a refusé

# @property construit exactement ce même trio __get__/__set__/__set_name__
# à partir des fonctions decorées -- rien de magique, un raccourci
L'ordre de priorité complet, descripteur de donnée comprisThe full priority order, data descriptor included
# L'algorithme réel de __getattribute__ (version complète du numéro 16) :
def getattribute_reelle(obj, nom):
    cls_attr = chercher_dans_mro(type(obj), nom)

    if est_descripteur_de_donnee(cls_attr):   # définit __get__ ET __set__
        return cls_attr.__get__(obj, type(obj))          # 1. PRIORITÉ ABSOLUE

    if nom in obj.__dict__:
        return obj.__dict__[nom]                          # 2. instance ensuite

    if cls_attr is not None:
        if est_descripteur_non_donnee(cls_attr):          # définit __get__ seul
            return cls_attr.__get__(obj, type(obj))        #    (ex: une méthode)
        return cls_attr                                    # 3. valeur de classe brute

    raise AttributeError(nom)
Pourquoi les méthodes ne cassent pas cette règleWhy methods don't break this rule

Une méthode ordinaire est un descripteur non-donnée : elle définit __get__ (c'est ce qui la lie à self) mais jamais __set__. C'est pourquoi self.ma_methode = autre_chose fonctionne sans lever d'erreur — l'instance peut toujours masquer un descripteur non-donnée, contrairement à une property.An ordinary method is a non-data descriptor: it defines __get__ (that's what binds it to self) but never __set__. That's why self.my_method = something_else works without raising — the instance can always shadow a non-data descriptor, unlike a property.

№ 04Le piègeThe trap4 min

Sans setter, une écriture lève une erreur. Sans cache, une lecture recalcule tout — à chaque fois.Without a setter, a write raises. Without a cache, a read recomputes everything — every single time.

Deux pièges se cachent derrière l'apparente simplicité de property. Le premier est visible immédiatement : une property sans setter refuse toute écriture, avec un message d'erreur qui peut surprendre puisque l'attribut semblait accessible en lecture. Le second est silencieux et coûte cher : property n'a aucune mémoire — son getter s'exécute intégralement à chaque lecture, même si rien n'a changé depuis le dernier appel. Pour une propriété coûteuse à calculer, chaque accès relance le travail en entier.Two traps hide behind property's apparent simplicity. The first is immediately visible: a property with no setter refuses any write, with an error message that can surprise since the attribute looked readable. The second is silent and costly: property has no memory at all — its getter runs in full on every read, even if nothing has changed since the last call. For an expensive-to-compute property, every access relaunches the whole job.

property sans setter reste un descripteur de donnée : priorité totale, mais écriture refuséeproperty with no setter stays a data descriptor: full priority, but writes refused
class Cercle:
    def __init__(self, rayon):
        self.rayon = rayon

    @property
    def aire(self):
        return 3.14159 * self.rayon ** 2
    # aucun @aire.setter défini -- __set__ n'existe pas pour cette property

c = Cercle(5)
c.aire = 100
# AttributeError: property 'aire' of 'Cercle' object has no setter

# une property SANS setter reste pourtant un descripteur DE DONNÉE
# (elle définit __set__ en interne, qui se contente de lever l'erreur) --
# elle garde donc sa priorité totale sur le __dict__ de l'instance
Le contre-usage de cached_propertycached_property's counter-use

Puisqu'il écrit sa valeur dans le __dict__ de l'instance, un cached_property ne se remet jamais à jour si les données source changent ensuite — c'est un bug, pas une optimisation, sur un objet muté fréquemment. Réserve-le aux attributs coûteux calculés une fois sur un objet qui ne change plus, ou invalide le cache manuellement (del self.resume) quand la source change.Since it writes its value into the instance's __dict__, a cached_property never refreshes if the source data changes afterward — that's a bug, not an optimization, on an object mutated frequently. Reserve it for expensive attributes computed once on an object that no longer changes, or manually invalidate the cache (del self.resume) when the source changes.

№ 05Bilan & éditoWrap-up & editorial2 min

Un attribut n'est pas toujours une case. Parfois, c'est une fonction qui a appris à se faire passer pour une case.An attribute isn't always a slot. Sometimes, it's a function that has learned to pass for one.

Ce numéro a creusé une exception à la règle posée au numéro 16 : trouver un attribut dans un __dict__ ne signifie pas toujours en retourner la valeur brute. Un descripteur — un objet définissant __get__, et pour property, __set__ aussi — intercepte l'accès et exécute du code à la place. La conséquence la plus contre-intuitive : un descripteur de donnée passe avant le __dict__ de l'instance, inversant l'ordre de priorité établi précédemment. Et parce qu'une property n'a aucune mémoire, chaque lecture recalcule tout — au point qu'un attribut coûteux mérite souvent cached_property plutôt que property.This issue dug into an exception to the rule set out in issue 16: finding an attribute in a __dict__ doesn't always mean returning its raw value. A descriptor — an object defining __get__, and for property, __set__ too — intercepts the access and runs code instead. The most counter-intuitive consequence: a data descriptor outranks the instance's __dict__, flipping the priority order established earlier. And because a property has no memory, every read recomputes everything — to the point that an expensive attribute often deserves cached_property rather than property.

NotionConceptCe qu'il faut en retenirWhat to take away
DescripteurDescriptorUn objet définissant __get__ (et parfois __set__) qui intercepte un accès attribut pour exécuter du code.An object defining __get__ (and sometimes __set__) that intercepts an attribute access to run code.
Donnée vs non-donnéeData vs non-dataUn descripteur de donnée (property) passe avant l'instance ; un descripteur non-donnée (une méthode) se laisse masquer par elle.A data descriptor (property) outranks the instance; a non-data descriptor (a method) lets the instance shadow it.
@propertyUn raccourci pour construire __get__/__set__/__set_name__ à partir de fonctions décorées.Shorthand for building __get__/__set__/__set_name__ from decorated functions.
cached_propertyCalcule une fois, écrit le résultat dans l'instance ; à réserver aux données qui ne changent plus.Computes once, writes the result into the instance; reserve it for data that no longer changes.
self.x n'a jamais promis d'être une case mémoire. Il a seulement promis de répondre — parfois en calculant, pas en se souvenant.self.x never promised to be a memory slot. It only promised to answer — sometimes by computing, not by remembering.
Mot de l'éditeurFrom the editor

Chaque instance porte son propre __dict__, prêt à accueillir n'importe quel attribut. Ce confort a un prix, en mémoire.Every instance carries its own __dict__, ready to welcome any attribute. That comfort has a memory price.

Les deux numéros de ce volume ont supposé, sans jamais le questionner, qu'une instance porte un __dict__ — un dictionnaire ordinaire, capable d'accueillir n'importe quel nom, à n'importe quel moment. C'est ce qui permet self.nouvel_attribut = valeur de fonctionner sans jamais déclarer nouvel_attribut à l'avance. Mais un dictionnaire par instance a un coût réel : de la mémoire allouée dynamiquement, une table de hachage entière, pour chaque objet créé — même quand la classe ne compte que deux ou trois attributs fixes, toujours les mêmes.Both issues in this volume have assumed, without ever questioning it, that an instance carries a __dict__ — an ordinary dictionary, able to welcome any name, at any time. That's what lets self.new_attribute = value work without ever declaring new_attribute ahead of time. But a per-instance dictionary has a real cost: dynamically allocated memory, a whole hash table, for every object created — even when the class only ever has two or three fixed attributes, always the same ones.

Prochain numéro : __slots__, le __dict__ a un coût. Pourquoi chaque instance porte un dict ; ce que __slots__ supprime — et interdit ; l'optimisation mémoire et son prix en flexibilité. Numéro de clôture du Vol. VI.Next issue: __slots__, the __dict__ has a cost. Why every instance carries a dict; what __slots__ removes — and forbids; the memory optimization and its price in flexibility. Closing issue of Vol. VI.