Le prix de la recherche dynamique The price of dynamic lookup

Le Vol. VI a montré comment obj.attr cherche — instance, classe, MRO. Ce dernier numéro chiffre ce que cette recherche coûte réellement, dans la boucle la plus chaude d'un programme, et montre où la mettre en cache. La boucle de la série se referme ici : le dynamisme n'a jamais été gratuit, seulement invisible. Vol. VI showed how obj.attr searches — instance, class, MRO. This final issue puts a number on what that search actually costs, in a program's hottest loop, and shows where to cache it. The series' loop closes here: dynamism was never free, only invisible.

Audience
Dev qui a écrit self.x dix mille fois dans une boucle chaude et n'a jamais mesuré ce que ça coûtait Dev who's written self.x ten thousand times in a hot loop and never measured what it cost
ChapitresChapters
5
LectureReading
≈ 21 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

PerformanceAttribute lookup__slots__

SommaireContents ·
№ 01CadrageFraming3 min

obj.attr n'est jamais un décalage mémoire — c'est une recherche, au mieux mise en cache, jamais supprimée.obj.attr is never a memory offset — it's a search, cached at best, never removed.

Le Vol. VI a détaillé comment Python résout obj.attr — d'abord le __dict__ de l'instance, puis celui de la classe, puis remontée du MRO (n°16), avec les descripteurs et property qui s'insèrent dans cette recherche (n°17), et __slots__ qui la modifie en remplaçant le dictionnaire par des emplacements fixes (n°18). Ce dernier numéro de la série pose la question restée en suspens depuis : tout cela a un coût, et ce coût n'est pas négligeable dans une boucle qui répète l'opération des millions de fois. Dans un langage à typage statique, obj.attr est résolu une fois, à la compilation, en un simple décalage mémoire. En Python, c'est en principe un appel de fonction — __getattribute__ — exécuté à chaque ligne, à chaque itération. Depuis Python 3.11, l'interpréteur spécialisant (PEP 659) raccourcit ce chemin quand il se répète à l'identique ; mais le raccourci doit être revérifié à chaque passage, et retombe sur la recherche complète dès que l'objet ou son type change de forme.Vol. VI detailed how Python resolves obj.attr — first the instance's __dict__, then the class's, then a walk up the MRO (issue №16), with descriptors and property inserting themselves into that search (issue №17), and __slots__ modifying it by replacing the dict with fixed slots (issue №18). This final issue in the series asks the question left hanging since then: all of this has a cost, and that cost isn't negligible in a loop that repeats the operation millions of times. In a statically typed language, obj.attr is resolved once, at compile time, into a simple memory offset. In Python, it's in principle a function call — __getattribute__ — executed on every line, every iteration. Since Python 3.11, the specializing interpreter (PEP 659) shortcuts that path when it repeats identically; but the shortcut must be rechecked on every pass, and falls back to the full search as soon as the object or its type changes shape.

Un décalage fixe ailleurs ; une recherche à chaque fois en PythonA fixed offset elsewhere; a search every time in Python
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
p.x   # dans un langage à typage statique : un décalage mémoire fixe,
       # calculé une fois à la compilation -- un accès quasi gratuit

       # en Python : obj.__getattribute__("x") -- une RECHERCHE, faite
       # à l'exécution -- p.__dict__, puis type(p), puis le MRO de
       # type(p), exactement le mécanisme du n°16. Depuis 3.11, CPython
       # mémorise le résultat à chaque site d'accès -- mais doit revérifier
       # ce raccourci à CHAQUE passage : un cache, jamais un décalage garanti
Le réflexe de tout le volumeThis whole volume's reflex

« Que coûte, au runtime, ce que le langage m'a laissé écrire gratuitement ? » — pour obj.attr, la réponse tient dans les trois chapitres qui suivent."What does this thing the language let me write for free actually cost at runtime?" — for obj.attr, the answer is in the next three chapters.

№ 02La surpriseThe surprise4 min

Une seule ligne changée avant la boucle — et la même boucle tourne mesurablement plus vite.One line changed before the loop — and the same loop measurably runs faster.

La surprise n'est pas que self.total coûte quelque chose — c'est que le coût est mesurable et évitable sans changer une seule ligne de logique. Deux versions strictement équivalentes en résultat : la première accède à self.total à chaque itération d'une boucle d'un million de tours, la seconde le copie une fois dans une variable locale avant la boucle, opère uniquement sur cette variable, puis réécrit le résultat dans self.total une seule fois à la fin. Chronométrées avec timeit, la seconde version tourne mesurablement plus vite — de l'ordre de 10 à 15 % en CPython 3.14, bien davantage avant 3.11 — la différence entre une recherche d'attribut refaite un million de fois et une recherche faite une seule fois, suivie d'un million d'accès à une variable locale, bien moins coûteux.The surprise isn't that self.total costs something — it's that the cost is measurable and avoidable without changing a single line of logic. Two versions, strictly equivalent in result: the first accesses self.total on every iteration of a million-turn loop, the second copies it once into a local variable before the loop, operates only on that variable, then writes the result back into self.total once at the end. Timed with timeit, the second version runs measurably faster — around 10 to 15% on CPython 3.14, much more before 3.11 — the difference between an attribute lookup redone a million times and one lookup done once, followed by a million accesses to a local variable, far cheaper.

Une recherche d'attribut à chaque itération de la boucleOne attribute lookup on every loop iteration
import timeit

class Accumulateur:
    def __init__(self):
        self.total = 0
    def calculer(self, n):
        for i in range(n):
            self.total += i     # self.total : une lecture ET une écriture
                                # d'attribut à chaque itération

a = Accumulateur()
t = timeit.timeit(lambda: a.calculer(1_000_000), number=1)
print(f"avec self.total répété : {t:.4f}s")
№ 03La mécaniqueThe mechanics5 min

LOAD_FAST lit un index dans un tableau ; LOAD_ATTR cherche — ou, spécialisé, vérifie un cache avant de lire.LOAD_FAST reads an index in an array; LOAD_ATTR searches — or, once specialized, checks a cache before reading.

Le module dis rend visible ce que le chapitre précédent a seulement mesuré. Une variable locale se compile en bytecode LOAD_FAST : l'interpréteur lit un emplacement précalculé dans le tableau des variables locales de la frame courante, par un simple index — l'équivalent presque exact d'un accès mémoire direct. Un accès obj.attr se compile en LOAD_ATTR, qui appelle __getattribute__ : hachage du nom, sondage du dictionnaire de l'instance, puis, en cas d'échec, remontée de tout le MRO de la classe (n°16), avec la vérification systématique des descripteurs de données à chaque étage (n°17). Depuis Python 3.11, l'interpréteur spécialisant (PEP 659) remplace ce LOAD_ATTR générique, après quelques passages, par une variante comme LOAD_ATTR_INSTANCE_VALUE : vérifier que le type n'a pas changé, puis lire la valeur à un emplacement mémorisé, sans hachage. L'écart s'est resserré ; il n'a pas disparu — le second chemin fait toujours plus de travail que le premier, de façon mesurable et cumulative sur des millions d'appels.The dis module makes visible what the previous chapter only measured. A local variable compiles to LOAD_FAST bytecode: the interpreter reads a precomputed slot in the current frame's local variables array, via a simple index — nearly the exact equivalent of a direct memory access. An obj.attr access compiles to LOAD_ATTR, which calls __getattribute__: hashing the name, probing the instance's dictionary, then, on failure, walking the entire class MRO (issue №16), with a systematic check for data descriptors at every level (issue №17). Since Python 3.11, the specializing interpreter (PEP 659) replaces that generic LOAD_ATTR, after a few passes, with a variant such as LOAD_ATTR_INSTANCE_VALUE: check that the type hasn't changed, then read the value at a remembered location, with no hashing. The gap has narrowed; it hasn't vanished — the second path still does more work than the first, measurably and cumulatively over millions of calls.

LOAD_ATTR refait son travail à chaque occurrenceLOAD_ATTR redoes its work at every occurrence
import dis

def avec_attribut(obj):
    return obj.valeur + obj.valeur

dis.dis(avec_attribut)       # sortie CPython 3.14, simplifiée
#  LOAD_FAST_BORROW  obj
#  LOAD_ATTR         valeur    <- recherche d'attribut : __dict__, MRO...
#  LOAD_FAST_BORROW  obj
#  LOAD_ATTR         valeur    <- refaite une seconde fois
#  BINARY_OP         (+)
#  RETURN_VALUE
LOAD_FAST : un index dans un tableau, pas une rechercheLOAD_FAST: an index into an array, not a search
import dis

def avec_variable_locale(obj):
    valeur = obj.valeur   # UNE SEULE recherche LOAD_ATTR
    return valeur + valeur

dis.dis(avec_variable_locale)
#  LOAD_FAST_BORROW  obj
#  LOAD_ATTR         valeur    <- une seule fois
#  STORE_FAST        valeur    <- rangé dans un emplacement FIXE de la frame
#  LOAD_FAST_BORROW_LOAD_FAST_BORROW  (valeur, valeur)
#                              <- deux accès DIRECTS par index, fusionnés
#  BINARY_OP         (+)
#  RETURN_VALUE

# LOAD_FAST lit un emplacement précalculé dans le tableau des variables
# locales de la frame -- un index, pas une recherche par nom. LOAD_ATTR,
# sous sa forme générique, appelle __getattribute__, qui hache une clé,
# sonde un dictionnaire, et peut remonter tout le MRO (n°16). Après
# quelques passages, CPython 3.11+ le spécialise : dis.dis(f, adaptive=True)
# montre alors LOAD_ATTR_INSTANCE_VALUE -- vérifier la version du type,
# puis lire à un emplacement mémorisé. Moins cher, jamais gratuit.
Ce que __slots__ change, et ne change pasWhat __slots__ changes, and doesn't

__slots__ (n°18) remplace le __dict__ de l'instance par des emplacements fixes en mémoire. Mais depuis 3.11, une instance ordinaire range déjà ses valeurs dans l'objet, et un LOAD_ATTR spécialisé les lit sans hachage : __slots__ ne change presque plus rien à la vitesse. Dans les deux cas, LOAD_ATTR reste plus coûteux qu'un LOAD_FAST : rien n'annule cet écart.__slots__ (issue №18) replaces the instance's __dict__ with fixed memory slots. But since 3.11 an ordinary instance already stores its values inside the object, and a specialized LOAD_ATTR reads them without hashing: __slots__ barely changes speed anymore. Either way, LOAD_ATTR remains costlier than a LOAD_FAST: nothing erases that gap.

№ 04Le piègeThe trap4 min

Mettre une méthode en cache avant la boucle : l'astuce classique — dont le gain, en 3.14, peut tomber à zéro.Caching a method before the loop: the classic trick — whose gain, on 3.14, can drop to zero.

Le piège concret le plus courant n'est pas un attribut de donnée mais une méthode liée, appelée en boucle sur un objet qui ne change jamais : self.resultats.append(...) répété des millions de fois exécute deux LOAD_ATTR à chaque tour, alors que la cible — la méthode append de cette liste précise — reste rigoureusement identique du début à la fin. Mettre cette méthode liée en cache dans une variable locale avant la boucle, une seule fois, transforme chaque appel suivant en un simple LOAD_FAST — avant Python 3.11, le gain était net. Mesuré en 3.14, il est nul sur cette boucle : l'interpréteur spécialise lui-même self.resultats.append en quelques vérifications de cache et un appel dédié. Le piège est donc double : laisser une vraie recherche coûteuse dans une boucle chaude, ou appliquer par réflexe une astuce que l'interpréteur a rendue inutile, et payer en lisibilité un gain qui n'existe plus.The most common concrete trap isn't a data attribute but a bound method, called in a loop on an object that never changes: self.resultats.append(...) repeated millions of times runs two LOAD_ATTR every time, even though the target — that specific list's append method — stays rigorously identical from start to finish. Caching that bound method into a local variable before the loop, just once, turns every subsequent call into a plain LOAD_FAST — before Python 3.11, the gain was clear. Measured on 3.14, it's zero on this loop: the interpreter itself specializes self.resultats.append into a few cache checks and a dedicated call. So the trap is twofold: leaving a genuinely costly lookup in a hot loop, or applying by reflex a trick the interpreter has made useless, and paying in readability for a gain that no longer exists.

10 millions de LOAD_ATTR pour une cible qui ne change jamais10 million LOAD_ATTR for a target that never changes
class Traitement:
    def __init__(self):
        self.resultats = []

    def traiter_lot(self, valeurs):
        for v in valeurs:
            # self.resultats.append : DEUX LOAD_ATTR par itération --
            # self.resultats, puis .append sur l'objet obtenu
            self.resultats.append(v * 2)

t = Traitement()
t.traiter_lot(range(5_000_000))
# fonctionne correctement -- mais sur 5 millions d'itérations, exécute
# 10 millions de LOAD_ATTR pour une opération qui ne change jamais de
# cible d'un tour à l'autre (depuis 3.11 : autant de vérifications de
# cache ; avant : autant de recherches complètes)
Le réflexe final de la sérieThe series' final reflex

Mesurer avant d'optimiser — timeit ou dis, jamais l'intuition seule — et réserver la mise en cache d'attribut aux boucles dont le coût a été vérifié réel. Le dynamisme de Python n'est jamais gratuit ; il est seulement, la plupart du temps, suffisamment bon marché pour qu'on ait raison de ne pas s'en soucier.Measure before optimizing — timeit or dis, never intuition alone — and reserve attribute caching for loops whose cost has been verified as real. Python's dynamism is never free; it's just, most of the time, cheap enough that it's right not to worry about it.

№ 05Bilan & éditoRecap & editorial2 min

Volume IX en une table — et la série au completVolume IX in one table — and the whole series

№No.TitreTitleTensionTension
25Comptage de références & cyclesReference counting & cyclesrefcount libère immédiatement ; un cycle attend le ramasse-miettesrefcount frees immediately; a cycle waits on the garbage collector
26Tout est objet, tout coûteEverything is an object, everything costsLe cache des petits int et l'interning rendent is trompeur au-delà de leurs bornesThe small-int cache and interning make is misleading beyond their boundaries
27Le prix de la recherche dynamiqueThe price of dynamic lookupobj.attr est une recherche, pas un décalage ; LOAD_FAST contre LOAD_ATTRobj.attr is a search, not an offset; LOAD_FAST versus LOAD_ATTR
Le dynamisme de Python n'a jamais été gratuit. Il était seulement invisible — jusqu'à ce qu'on prenne la peine de le mesurer.Python's dynamism was never free. It was only invisible — until someone bothered to measure it.
Fin de la série — la boucle se refermeEnd of the series — the loop closes

Vingt-sept numéros plus tôt, le n°01 posait une seule question : b = a copie-t-il, ou lie-t-il un second nom au même objet ? Chaque volume qui a suivi en a tiré une conséquence — l'aliasing, les arguments par défaut, le duck typing, la portée, la recherche d'attribut, les ressources, la concurrence — jusqu'à ce dernier numéro, qui referme la boucle exactement là où tout a commencé : is compare des identités, ces identités ont un coût, et ce coût n'a jamais été absent — seulement tenu, avec soin, hors de vue. Savoir enfin ce que la facilité coûtait, c'était tout le pari de The Python Loop.Twenty-seven issues ago, issue №01 asked a single question: does b = a copy, or bind a second name to the same object? Every volume since drew a consequence from it — aliasing, default arguments, duck typing, scope, attribute lookup, resources, concurrency — until this final issue, which closes the loop exactly where it all began: is compares identities, those identities have a cost, and that cost was never absent — only kept, carefully, out of sight. Finally knowing what ease cost all along was the whole bet of The Python Loop.