Tout est objet, tout coûte Everything is an object, everything costs

Le Vol. I a posé is contre == sans jamais expliquer pourquoi a is b « marche » parfois. La réponse tenait dans ce numéro : CPython pré-alloue un cache de petits entiers et interne certaines chaînes au démarrage. a is b n'est vrai par coïncidence que pour les valeurs qui tombent dans ce cache — et se brise, sans prévenir, dès qu'on en sort. Vol. I posed is versus == without ever explaining why a is b sometimes 'works'. The answer was waiting in this issue: CPython preallocates a small-int cache and interns certain strings at startup. a is b is only true by coincidence for values that fall inside that cache — and breaks, without warning, the moment you step outside it.

Audience
Dev qui a vu a is b marcher en REPL avec de petits entiers et l'a généralisé, à tort, en code de production Dev who saw a is b work in the REPL with small integers and wrongly generalized it into production code
ChapitresChapters
5
LectureReading
≈ 19 min
NiveauLevel
●●●○
Date
Juil 2026 Jul 2026

is vs ==InterningCPython

SommaireContents ·
№ 01CadrageFraming3 min

Le tout premier numéro de la série posait la règle sans jamais expliquer pourquoi elle semblait avoir des exceptions.The very first issue of the series stated the rule without ever explaining why it seemed to have exceptions.

Le n°01 a ouvert toute la série sur une distinction fondatrice : is compare l'identité de deux objets — sont-ils littéralement le même objet en mémoire, le même id() — tandis que == compare leur valeur. Mais une question restait en suspens : pourquoi deux entiers valant 256, calculés à l'exécution, sont-ils le même objet, alors que deux entiers valant 257 ne le sont pas, quand == aurait répondu True dans les deux cas sans exception ? La réponse tenait dans un détail d'implémentation de CPython jamais encore nommé : certains objets, en nombre volontairement limité, sont créés une seule fois au démarrage de l'interpréteur, puis partagés — jamais recréés — chaque fois que leur valeur revient dans le code. Deux petits entiers égaux à 256 ne sont donc pas seulement égaux : ce sont, littéralement, le même objet.Issue №01 opened the entire series with a founding distinction: is compares the identity of two objects — are they literally the same object in memory, the same id() — while == compares their value. But a question was left hanging: why are two integers worth 256, computed at runtime, the same object, while two integers worth 257 are not, when == would have answered True in both cases without exception? The answer lay in a CPython implementation detail never yet named: certain objects, in a deliberately limited number, are created exactly once at interpreter startup, then shared — never recreated — every time their value comes up again in the code. Two small integers equal to 256 aren't just equal, then: they are, literally, the same object.

La règle du n°01, confrontée à 256 et 257Issue №01's rule, faced with 256 and 257
# la règle du n°01, appliquée à des entiers calculés à l'exécution :
a = int("256")
b = int("256")
print(a is b)   # True -- "is" compare l'IDENTITÉ (id()), pas la valeur

a = int("257")
b = int("257")
print(a is b)   # False -- pourtant, == aurait donné True dans les deux cas

# (a = 257; b = 257 écrits tels quels dans un script donneraient True :
# le compilateur partage les constantes identiques d'un même bloc.)
# Mais pourquoi 256 se comporte-t-il différemment de 257 ?
# La réponse n'a jamais été donnée -- jusqu'à ce numéro.
La boucle se refermeThe loop closes

Ce numéro ne présente pas une nouvelle règle : il explique enfin celle posée au tout premier numéro de la série. Le prix invisible du dynamisme n'est jamais mieux visible qu'ici, dans une coïncidence d'implémentation prise, à tort, pour une garantie du langage.This issue doesn't introduce a new rule: it finally explains the one stated in the series' very first issue. The invisible price of dynamism is never more visible than here, in an implementation coincidence wrongly mistaken for a language guarantee.

№ 02La surpriseThe surprise4 min

La frontière entre « ça marche » et « ça casse » est une constante précise, cachée dans le code source de CPython.The line between "it works" and "it breaks" is a precise constant, hidden in CPython's source code.

La surprise n'est pas que is se comporte de façon incohérente — il est parfaitement cohérent, à condition de connaître la règle exacte qu'aucune erreur ne signale jamais. Pour les entiers, CPython pré-alloue au démarrage les objets correspondant aux valeurs de -5 à 256 inclus, et les réutilise pour toute apparition ultérieure de ces valeurs — une frontière fixée dans le code source de l'interpréteur, pas une propriété du langage Python lui-même. Pour les chaînes, un mécanisme voisin mais plus flou — l'interning — réutilise automatiquement certains littéraux qui ressemblent à des identifiants de variable, sans jamais garantir ce comportement pour des chaînes construites dynamiquement, même strictement égales par ==.The surprise isn't that is behaves inconsistently — it's perfectly consistent, provided you know the exact rule that no error ever signals. For integers, CPython preallocates at startup the objects corresponding to values from -5 to 256 inclusive, and reuses them for every later occurrence of those values — a boundary fixed in the interpreter's source code, not a property of the Python language itself. For strings, a related but blurrier mechanism — interning — automatically reuses certain literals that look like variable identifiers, without ever guaranteeing that behavior for dynamically built strings, even ones strictly equal by ==.

-5 <= n <= 256 : le même objet ; en dehors : deux objets distincts-5 <= n <= 256: the same object; outside: two distinct objects
# valeurs produites à l'exécution (lues, parsées, calculées) --
# des littéraux identiques dans un même bloc partageraient leur constante
a, b = int("256"), int("256")
print(a is b)   # True -- 256 est DANS le cache des petits entiers (-5 à 256)

a, b = int("257"), int("257")
print(a is b)   # False -- 257 est HORS du cache : deux objets distincts,
                 # créés séparément, qui se trouvent avoir la même valeur

a, b = int("-5"), int("-5")
print(a is b)   # True -- borne basse du cache

a, b = int("-6"), int("-6")
print(a is b)   # False -- juste hors de la borne basse

# la frontière est exactement -5 <= n <= 256 -- ni un hasard,
# ni une propriété du langage : une constante fixée dans le code
# source de CPython (Objects/longobject.c)
№ 03La mécaniqueThe mechanics5 min

Le cache et l'interning existent pour épargner au comptage de références un travail inutile, répété des millions de fois.The cache and interning exist to spare reference counting pointless work, repeated millions of times.

Ces mécanismes ne sont pas des accidents d'implémentation : ils existent pour une raison de performance directement liée au comptage de références du numéro précédent. Un entier comme 0, 1, ou -1 revient si souvent dans un programme typique — chaque compteur de boucle qui repasse par zéro, chaque booléen, chaque longueur de liste vide — que l'allouer et le libérer à chaque usage coûterait un temps réel, multiplié par des millions d'occurrences. En pré-allouant ces valeurs une fois pour toutes et en les partageant, CPython transforme une allocation en simple réutilisation — et depuis Python 3.12 (PEP 683), sans même toucher au compteur de ces objets immortels. Le même raisonnement s'applique aux chaînes qui ressemblent à des identifiants — noms de variables, clés de dictionnaire répétées — via sys.intern(), que le compilateur appelle automatiquement sur certains littéraux.These mechanisms aren't implementation accidents: they exist for a performance reason directly tied to the previous issue's reference counting. An integer like 0, 1, or -1 comes up so often in a typical program — every loop counter passing through zero, every boolean, every empty list's length — that allocating and freeing it on every use would cost real time, multiplied by millions of occurrences. By preallocating these values once and for all and sharing them, CPython turns an allocation into a simple reuse — and since Python 3.12 (PEP 683), without even touching the count of these immortal objects. The same reasoning applies to strings that look like identifiers — variable names, repeated dictionary keys — via sys.intern(), which the compiler calls automatically on certain literals.

sys.intern() force explicitement ce que le compilateur fait parfois seulsys.intern() explicitly forces what the compiler sometimes does alone
import sys

a = "".join(["s", "a", "l", "u", "t"])
b = "".join(["s", "a", "l", "u", "t"])
print(a is b)   # False -- deux objets str distincts, construits séparément

a = sys.intern("".join(["s", "a", "l", "u", "t"]))
b = sys.intern("".join(["s", "a", "l", "u", "t"]))
print(a is b)   # True -- sys.intern() FORCE le partage explicitement,
                 # exactement le mécanisme qu'un littéral "salut" déclenche
                 # automatiquement à la compilation
Le cache transforme une allocation répétée en simple réutilisationThe cache turns a repeated allocation into a simple reuse
# Pourquoi ce cache existe : le comptage de références (n°25) fait
# qu'un entier très utilisé -- 0, 1, True (qui EST 1), la longueur
# d'une liste vide -- serait alloué et libéré des millions de fois
# par seconde dans un programme typique, sans ce cache.

# Sans cache (hypothétique) : chaque 'x = 0' alloue un nouvel objet PyLong,
# incrémente son refcount, et le libère à la prochaine réassignation --
# un coût réel, répété à chaque itération de boucle, chaque comparaison.

# Avec cache : 'x = 0' ne fait QUE réutiliser l'objet 0, créé au
# démarrage de l'interpréteur -- aucune allocation, aucune libération.
# Depuis Python 3.12 (PEP 683), ces petits entiers sont même IMMORTELS :
# leur compteur de références n'est plus modifié du tout.

import sys
print(sys.getrefcount(0))          # 3221225472 (3.14) -- valeur sentinelle
print(int("0") is int("0"))        # True -- même objet, littéralement
Une optimisation, jamais une garantieAn optimization, never a guarantee

Rien dans la spécification du langage Python n'impose ce cache ni ces bornes précises — c'est un détail d'implémentation de CPython, qui pourrait changer d'une version à l'autre sans casser la compatibilité du langage. S'appuyer sur is pour comparer des valeurs, c'est s'appuyer sur un détail d'implémentation, jamais sur une règle du langage.Nothing in the Python language specification mandates this cache or these precise boundaries — it's a CPython implementation detail, which could change between versions without breaking language compatibility. Relying on is to compare values means relying on an implementation detail, never on a language rule.

№ 04Le piègeThe trap4 min

Un is utilisé à la place d'un == peut fonctionner pendant des mois avant de se briser sans prévenir.An is used instead of == can work for months before silently breaking.

Le piège le plus insidieux de ce numéro n'est pas théorique : utiliser is pour comparer deux valeurs numériques, par erreur ou par habitude héritée d'un autre langage, fonctionne parfaitement tant que ces valeurs restent dans le cache des petits entiers — souvent le cas en développement, avec des exemples et des tests qui utilisent de petits nombres par commodité. Le bug reste invisible, couvert par une coïncidence d'implémentation, jusqu'au jour où une valeur dépasse 256, ou change de type, ou provient d'un calcul dont le résultat n'est jamais mis en cache. Il se manifeste alors en production, sans erreur, sans trace — juste une comparaison qui répond faux là où elle répondait vrai auparavant, pour une raison que rien dans le code ne documente.This issue's most insidious trap isn't theoretical: using is to compare two numeric values, by mistake or by habit inherited from another language, works perfectly as long as those values stay inside the small-int cache — often the case in development, with examples and tests using small numbers for convenience. The bug stays invisible, covered by an implementation coincidence, until the day a value exceeds 256, or changes type, or comes from a computation whose result is never cached. It then shows up in production, with no error, no trace — just a comparison that returns false where it used to return true, for a reason nothing in the code documents.

Fonctionne en dev (petits nombres), casse en production (300)Works in dev (small numbers), breaks in production (300)
LIMITE_GRATUITE = 5

def a_atteint_le_quota(nb_articles_lus):
    return nb_articles_lus is LIMITE_GRATUITE   # PIÈGE : is au lieu de ==

# testé en développement, avec un compteur lu en base (ici : int(...)) :
print(a_atteint_le_quota(int("5")))     # True -- 5 est dans le cache, "ça marche"

# ... des mois plus tard, la limite gratuite passe à 300 articles
# (au-delà du cache -5..256) :
LIMITE_GRATUITE = 300
print(a_atteint_le_quota(int("300")))   # False -- deux objets 300 distincts
# le quota n'est plus jamais détecté, silencieusement, sans qu'aucune
# exception ne le signale. Le bug dormait depuis le début, masqué par le cache.
# (300 is 300 écrit en dur déclencherait un SyntaxWarning depuis 3.8 --
# ici, rien ne prévient : les valeurs n'arrivent qu'à l'exécution.)
Le seul usage légitime de isThe only legitimate use of is

Réserver is à la comparaison avec des singletons du langage — None, True, False — qui sont, eux, garantis uniques par la spécification elle-même, pas par un cache d'implémentation. Pour toute autre valeur, ==.Reserve is for comparisons against the language's own singletons — None, True, False — which are guaranteed unique by the specification itself, not by an implementation cache. For any other value, ==.

№ 05Bilan & éditoRecap & editorial2 min

Ce numéro en une tableThis issue in one table

№No.TitreTitleTensionTension
26Tout est objet, tout coûteEverything is an object, everything costsLe cache des petits int et l'interning des chaînes rendent is trompeur au-delà de leurs bornesThe small-int cache and string interning make is misleading beyond their boundaries
Le n°01 disait : « is compare l'identité ». Ce numéro ajoute ce qu'aucune erreur ne dit jamais : cette identité est parfois un cadeau de l'interpréteur, pas une propriété de la valeur.Issue №01 said: "is compares identity." This issue adds what no error ever says: that identity is sometimes a gift from the interpreter, not a property of the value.
Dernier numéro de la série — №27Final issue of the series — No. 27

Ce numéro a montré ce que coûte, invisiblement, le simple fait que tout soit objet en Python. Le №27 referme la boucle en s'attaquant à la dernière question restée en suspens depuis le Vol. VI : chaque obj.attr, chaque obj.methode() est une recherche — un parcours de __dict__, puis de MRO. Ce numéro chiffre ce coût, montre où le mettre en cache dans une boucle chaude, et referme la série exactement là où elle a commencé.This issue showed what the simple fact of everything being an object in Python invisibly costs. No. 27 closes the loop by tackling the last question left hanging since Vol. VI: every obj.attr, every obj.method() is a lookup — a walk through __dict__, then the MRO. This issue puts a number on that cost, shows where to cache it in a hot loop, and closes the series exactly where it began.