La recherche d'attribut : instance, classe, MRO Attribute lookup: instance, class, MRO

obj.x n'est jamais une simple lecture de case mémoire : c'est une recherche, dans un ordre fixe. Python regarde d'abord le __dict__ de l'instance ; s'il n'y trouve rien, il remonte le __dict__ de la classe, puis celui de chaque classe parente, dans l'ordre du MRO. Une liste posée comme attribut de classe est donc partagée par toutes les instances — jusqu'à ce que l'une d'elles écrive enfin la sienne. obj.x is never a plain memory-slot read: it's a search, in a fixed order. Python first looks at the instance's __dict__; finding nothing there, it climbs the class's __dict__, then each parent class's, in MRO order. A list set as a class attribute is therefore shared by every instance — until one of them finally writes its own.

Audience
Dev qui a vu une liste censée être propre à chaque instance se remplir pour tout le monde à la fois Dev who's watched a list meant to be per-instance fill up for everyone at once
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

AttributsMRO__dict__

SommaireContents ·
№ 01CadrageFraming3 min

Le Vol. V résolvait un nom libre dans le temps. Ce volume résout un attribut dans l'espace : où vit-il ?Vol. V resolved a free name in time. This volume resolves an attribute in space: where does it live?

LEGB (numéros 13 à 15) répondait à une question précise : où chercher un nom qui n'appartient à aucun objet — une variable ordinaire, lue dans une fonction. Mais obj.x pose une question voisine, jamais couverte jusqu'ici : où chercher un attribut qui appartient, lui, à un objet précis ? La réponse est une seconde recherche à étages, tout aussi mécanique que LEGB, mais qui parcourt un axe différent : d'abord le dictionnaire de l'instance elle-même, puis celui de sa classe. j.nom et j.vie empruntent le même point d'entrée — la syntaxe obj.attribut — et pourtant ne vivent pas au même étage.LEGB (issues 13 through 15) answered a precise question: where to look for a name that belongs to no object — an ordinary variable, read inside a function. But obj.x asks a neighboring question, never covered so far: where to look for an attribute that belongs, specifically, to one object? The answer is a second tiered search, just as mechanical as LEGB, but walking a different axis: first the instance's own dictionary, then its class's. j.nom and j.vie go through the same entry point — the obj.attribute syntax — and yet don't live on the same floor.

Même syntaxe, deux étages différentsSame syntax, two different floors
class Joueur:
    vie = 100                 # attribut de CLASSE

    def __init__(self, nom):
        self.nom = nom        # attribut d'INSTANCE

j = Joueur("Aria")
print(j.nom)     # "Aria"    -- trouvé dans j.__dict__
print(j.vie)     # 100       -- absent de j.__dict__, trouvé dans Joueur.__dict__

print(j.__dict__)          # {'nom': 'Aria'}  -- "vie" n'y est PAS
print(Joueur.__dict__['vie'])   # 100 -- c'est LÀ qu'il vit vraiment
Le sous-réflexe du numéroThis issue's sub-reflex

Face à un obj.attribut, demande : cet attribut vit-il dans le __dict__ de cette instance précise, ou seulement dans celui de sa classe — partagé, donc, par toutes les autres instances ?Facing an obj.attribute, ask: does this attribute live in this specific instance's __dict__, or only in its class's — shared, then, by every other instance?

Ce n'est pas un hasard de vocabulaireIt's not a coincidence of vocabulary

LEGB et la recherche d'attribut partagent la même logique : chercher d'abord au plus près, remonter par étages fixes si rien n'est trouvé, s'arrêter à la première correspondance. LEGB remonte des portées de fonctions ; la recherche d'attribut remonte une chaîne d'héritage — le MRO, sujet du chapitre 3.LEGB and attribute lookup share the same logic: look closest first, climb through fixed tiers if nothing is found, stop at the first match. LEGB climbs function scopes; attribute lookup climbs an inheritance chain — the MRO, the subject of chapter 3.

№ 02La surpriseThe surprise4 min

Une liste posée comme attribut de classe n'est jamais à toi seul — elle est à toutes les instances, à la fois.A list set as a class attribute is never yours alone — it belongs to every instance, at once.

La surprise recroise directement le numéro 03 sur les arguments par défaut mutables — même piège, autre porte d'entrée. membres = [] écrit au niveau de la classe crée une seule liste, une seule fois, à la définition de la classe. Chaque instance qui n'a jamais assigné membres elle-même ne trouve rien dans son propre __dict__ — la recherche remonte alors jusqu'à la classe, et toutes les instances remontent vers la même case. .append() mute cette case commune ; il ne la réassigne jamais, donc aucune instance ne se crée jamais sa propre copie au passage.The surprise directly echoes issue 03 on mutable default arguments — same trap, different door. membres = [] written at the class level creates one single list, once, at class-definition time. Every instance that has never assigned membres itself finds nothing in its own __dict__ — the lookup then climbs to the class, and every instance climbs to that same slot. .append() mutates that shared slot; it never reassigns it, so no instance ever creates its own copy along the way.

Deux équipes, une seule liste de membresTwo teams, one single member list
class Equipe:
    membres = []          # attribut de CLASSE -- une seule liste, créée une fois

    def __init__(self, capitaine):
        self.membres.append(capitaine)   # .append() MUTE -- ne réassigne jamais "membres"

bleus = Equipe("Aria")
rouges = Equipe("Kofi")

print(bleus.membres)     # ['Aria', 'Kofi'] !
print(rouges.membres)    # ['Aria', 'Kofi'] !
print(bleus.membres is rouges.membres)   # True -- LA MÊME liste

# les deux équipes se partagent silencieusement le même objet,
# parce qu'aucune des deux instances ne possède "membres" en propre
Un attribut de classe n'est pas une valeur par défaut par instance. C'est un objet unique, que la recherche fait juste sembler personnel.A class attribute isn't a per-instance default. It's a single object that lookup just makes look personal.
№ 03La mécaniqueThe mechanics5 min

D'abord l'instance, puis chaque classe dans l'ordre exact du MRO — jamais dans un autre ordre.First the instance, then every class in the MRO's exact order — never in another order.

Quand une classe hérite d'une autre, qui elle-même hérite d'une autre, obj.attribut ne remonte pas au hasard : Python calcule à l'avance une liste linéaire et fixe de toutes les classes concernées — le Method Resolution Order, ou MRO — et la parcourt dans cet ordre précis, en s'arrêtant à la première classe qui possède l'attribut dans son __dict__. Une sous-classe qui redéfinit un attribut coupe donc la recherche avant qu'elle n'atteigne les classes parentes, exactement comme une variable locale coupe la recherche LEGB avant qu'elle n'atteigne le Global.When a class inherits from another, which itself inherits from another, obj.attribute doesn't climb at random: Python computes ahead of time a fixed, linear list of every class involved — the Method Resolution Order, or MRO — and walks it in that exact order, stopping at the first class that owns the attribute in its __dict__. A subclass that redefines an attribute therefore cuts the search short before it reaches the parent classes, exactly like a local variable cuts the LEGB search short before it reaches Global.

__mro__ expose littéralement l'ordre de recherche__mro__ literally exposes the search order
class Animal:
    regime = "inconnu"

class Chien(Animal):
    pass

class Labrador(Chien):
    regime = "omnivore"     # redéfini ici

l = Labrador()
print(l.regime)     # "omnivore" -- trouvé dans Labrador, la recherche s'arrête là

print(Labrador.__mro__)
# (Labrador, Chien, Animal, object)
# -- l'ORDRE EXACT dans lequel Python cherche un attribut de classe
L'algorithme, réduit à l'essentielThe algorithm, reduced to its essentials
# L'algorithme simplifié de obj.attribut
# (simplifié : un descripteur de données de la classe, comme une property,
#  passe même AVANT le __dict__ de l'instance -- voir le n°17) :
def getattr_simplifie(obj, nom):
    if nom in obj.__dict__:
        return obj.__dict__[nom]          # 1. le __dict__ de L'INSTANCE d'abord

    for classe in type(obj).__mro__:      # 2. puis chaque classe, dans l'ordre du MRO
        if nom in classe.__dict__:
            return classe.__dict__[nom]

    raise AttributeError(nom)             # 3. rien trouvé nulle part -> erreur

# la vraie recherche (via __getattribute__) est plus riche -- elle traite
# aussi les descripteurs (numéro 17) -- mais cette séquence en est le cœur
Pourquoi ne pas juste chercher partout ?Why not just search everywhere?

Avec l'héritage multiple, plusieurs classes parentes pourraient posséder le même nom d'attribut avec des valeurs différentes. Sans un ordre fixe et déterministe, deux exécutions du même programme pourraient en théorie choisir des attributs différents. Le MRO élimine cette ambiguïté une fois pour toutes, à la création de la classe.With multiple inheritance, several parent classes could own the same attribute name with different values. Without a fixed, deterministic order, two runs of the same program could in theory pick different attributes. The MRO eliminates that ambiguity once and for all, at class-creation time.

№ 04Le piègeThe trap4 min

__getattr__ est un filet de secours ; __getattribute__ intercepte tout — y compris son propre appel à self.__getattr__ is a safety net; __getattribute__ intercepts everything — including its own call to self.

Les deux méthodes spéciales portent presque le même nom et rendent presque le même service, mais interviennent à des moments radicalement différents. __getattr__ n'est appelée qu'en dernier recours, quand la recherche normale du chapitre 3 — instance, puis MRO — n'a rien trouvé et s'apprête à lever AttributeError. __getattribute__, elle, intercepte absolument chaque accès à un attribut, y compris ceux qui auraient normalement réussi sans elle. La surcharger est tentant pour logguer ou valider tous les accès — et c'est exactement là que se cache le piège le plus classique du chapitre : toute lecture d'attribut à l'intérieur de __getattribute__, y compris self.__dict__, redéclenche __getattribute__ elle-même.The two special methods share almost the same name and render almost the same service, but fire at radically different moments. __getattr__ is only called as a last resort, when the normal lookup from chapter 3 — instance, then MRO — has found nothing and is about to raise AttributeError. __getattribute__, on the other hand, intercepts absolutely every attribute access, including ones that would have succeeded fine without it. Overriding it is tempting for logging or validating every access — and that's exactly where this chapter's most classic trap hides: any attribute read inside __getattribute__, including self.__dict__, retriggers __getattribute__ itself.

Appelée seulement quand la recherche normale échoueCalled only when the normal lookup fails
class Config:
    def __init__(self):
        self.debug = True

    def __getattr__(self, nom):
        # appelé SEULEMENT si la recherche normale (instance, puis MRO) a échoué
        return f"valeur par défaut pour {nom}"

c = Config()
print(c.debug)          # True -- trouvé normalement, __getattr__ n'est JAMAIS appelé
print(c.timeout)        # "valeur par défaut pour timeout" -- __getattr__ prend le relai

# __getattr__ est un FILET DE SÉCURITÉ, pas un point de passage systématique
Quand ne surcharger ni l'un ni l'autreWhen to override neither

Pour la plupart des besoins — une valeur par défaut, un attribut calculé, une validation à l'écriture — property (numéro 17) ou __getattr__ seul suffisent, sans le risque de récursion. __getattribute__ ne se justifie que pour intercepter systématiquement tous les accès d'un objet, un besoin rare (proxies, ORM, journalisation exhaustive).For most needs — a default value, a computed attribute, validation on write — property (issue 17) or __getattr__ alone are enough, without the recursion risk. __getattribute__ is only justified when systematically intercepting every access to an object, a rare need (proxies, ORMs, exhaustive logging).

№ 05Bilan & éditoWrap-up & editorial2 min

obj.x n'a jamais été une lecture. C'était une recherche, à étages fixes, qui s'arrête au premier étage qui répond.obj.x was never a read. It was a search, through fixed tiers, stopping at the first tier that answers.

Ce numéro a posé le pendant spatial de LEGB. Un attribut est cherché d'abord dans le __dict__ de l'instance, puis dans celui de la classe et de chaque classe parente, dans l'ordre exact et précalculé du MRO — jamais au hasard, jamais dans un ordre qui varierait d'une exécution à l'autre. Le piège classique — une liste posée comme attribut de classe, silencieusement partagée par toutes les instances — n'est que le numéro 03 rejoué sur un axe différent. Et __getattr__ contre __getattribute__ a montré que la recherche elle-même peut être interceptée : l'une en dernier recours, l'autre à chaque accès, au risque de se rappeler elle-même à l'infini.This issue laid out LEGB's spatial counterpart. An attribute is looked up first in the instance's __dict__, then in the class's and each parent class's, in the MRO's exact, precomputed order — never at random, never in an order that would vary from one run to the next. The classic trap — a list set as a class attribute, silently shared by every instance — is only issue 03 replayed on a different axis. And __getattr__ versus __getattribute__ showed that the search itself can be intercepted: one as a last resort, the other on every access, at the risk of calling itself forever.

NotionConceptCe qu'il faut en retenirWhat to take away
Instance avant classeInstance before classobj.x cherche d'abord obj.__dict__, puis remonte à la classe seulement si rien n'y est trouvé.obj.x checks obj.__dict__ first, climbing to the class only if nothing is found there.
MROL'ordre fixe et précalculé dans lequel les classes parentes sont consultées ; exposé via __mro__.The fixed, precomputed order in which parent classes are consulted; exposed via __mro__.
Attribut de classe mutableMutable class attributeUne seule case, partagée par toutes les instances qui n'ont pas encore écrit la leur — le piège du numéro 03, version attribut.A single slot, shared by every instance that hasn't yet written its own — issue 03's trap, attribute edition.
__getattr__ / __getattribute__Le premier n'intervient qu'en cas d'échec ; le second intercepte tout, y compris ses propres accès à self.The former only fires on failure; the latter intercepts everything, including its own accesses to self.
Un attribut n'appartient jamais vraiment à l'instance. Il appartient à celle qui répond la première, quand on remonte la chaîne.An attribute never truly belongs to the instance. It belongs to whichever one answers first, as you climb the chain.
Mot de l'éditeurFrom the editor

La recherche s'arrête au premier __dict__ qui répond. Mais que se passe-t-il quand cette réponse n'est pas une valeur — mais du code ?The search stops at the first __dict__ that answers. But what happens when that answer isn't a value — but code?

Ce numéro a supposé que trouver un attribut dans un __dict__ suffisait à répondre. Ce n'est pas toujours vrai. Le numéro 08 (les dunders) avait déjà montré que len(x) n'est qu'un appel déguisé à x.__len__() ; le prochain numéro applique la même idée à un accès d'apparence anodine, self.x. Certains objets trouvés dans un __dict__ de classe ne sont pas des valeurs à retourner telles quelles — ce sont des descripteurs, qui définissent __get__ et __set__, et transforment un accès banal en exécution de code. property en est l'exemple le plus utilisé.This issue assumed that finding an attribute in a __dict__ was enough to answer. That's not always true. Issue 08 (dunders) already showed that len(x) is just disguised syntax for x.__len__(); the next issue applies the same idea to an access that looks utterly plain, self.x. Some objects found in a class __dict__ aren't values to return as-is — they're descriptors, which define __get__ and __set__, and turn an ordinary access into code execution. property is the most-used example.

Prochain numéro : les descripteurs & property. self.x qui déclenche un getter ; le protocole __get__/__set__ ; comment @property transforme un attribut en méthode déguisée.Next issue: descriptors & property. self.x triggering a getter; the __get__/__set__ protocol; how @property turns an attribute into a disguised method.