Comptage de références & cycles Reference counting & cycles

Le n°24 a mentionné une référence faible, sans expliquer ce qui distingue une référence forte. La réponse ouvre le dernier volume de la série : chaque objet Python porte un compteur de références, et meurt à l'instant précis où ce compteur atteint zéro — sauf quand deux objets se référencent mutuellement, et qu'aucun compteur ne redescend jamais à zéro tout seul. Issue №24 mentioned a weak reference, without explaining what sets a strong reference apart. The answer opens the series' final volume: every Python object carries a reference count, and dies at the exact instant that count hits zero — except when two objects reference each other, and no count ever drops to zero on its own.

Audience
Dev qui pense que Python a un garbage collector "comme Java" et ne sait pas que la plupart des objets meurent instantanément, sans lui Dev who thinks Python has a garbage collector "like Java" and doesn't know most objects die instantly, without it
ChapitresChapters
5
LectureReading
≈ 20 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

RefcountGarbage collector__del__

SommaireContents ·
№ 01CadrageFraming3 min

Un objet Python ne meurt pas « à un moment donné » — il meurt à l'instant exact où son compteur touche zéro.A Python object doesn't die "at some point" — it dies at the exact instant its counter hits zero.

Le numéro précédent a mentionné une référence faible, sans expliquer ce qui la distingue d'une référence forte — la voici. Chaque objet Python porte un entier caché, son compteur de références, qui s'incrémente à chaque nouvelle référence forte créée vers lui (une variable, un élément de liste, un attribut) et se décrémente à chaque suppression. La règle est mécanique et immédiate : dès que ce compteur atteint zéro, l'objet est détruit sur-le-champ, sa mémoire libérée, sans attendre le passage d'un quelconque ramasse-miettes différé. C'est très différent du modèle « tas balayé périodiquement » d'autres langages à garbage collector — en CPython, la libération de la plupart des objets est déterministe et instantanée.The previous issue mentioned a weak reference, without explaining what sets it apart from a strong one — here it is. Every Python object carries a hidden integer, its reference count, which increments with every new strong reference created toward it (a variable, a list element, an attribute) and decrements with every deletion. The rule is mechanical and immediate: as soon as that count hits zero, the object is destroyed on the spot, its memory freed, without waiting for any deferred garbage collector to pass by. This is very different from the 'heap swept periodically' model of other garbage-collected languages — in CPython, the release of most objects is deterministic and instantaneous.

__del__ s'exécute au moment exact où le compteur atteint zéro__del__ runs at the exact moment the counter hits zero
import sys

class Ressource:
    def __del__(self):
        print("Ressource libérée")

r = Ressource()
print(sys.getrefcount(r) - 1)   # -1 pour l'argument temporaire de l'appel : 1

r2 = r                            # une deuxième référence
print(sys.getrefcount(r) - 1)    # 2

del r2                            # une référence en moins
print(sys.getrefcount(r) - 1)    # 1

del r
# "Ressource libérée" s'affiche ICI, à l'instant précis du second del --
# pas "à un moment donné", pas "au prochain passage du GC" : maintenant,
# parce que le compteur de références vient d'atteindre zéro
Le réflexe du numéroThis issue's reflex

Une référence forte compte pour le refcount ; une référence faible (weakref, ou celle que la boucle asyncio garde sur une Task, n°24) n'y participe jamais.A strong reference counts toward refcount; a weak reference (weakref, or the one the asyncio loop keeps on a Task, issue №24) never participates in it.

№ 02La surpriseThe surprise4 min

Deux objets qui se référencent mutuellement ne libèrent jamais rien — le compteur ne descend jamais à zéro tout seul.Two objects referencing each other never release anything — the counter never drops to zero on its own.

La surprise n'est pas que le refcount fonctionne bien — le chapitre précédent l'a montré, il fonctionne remarquablement bien, pour le cas le plus courant. La surprise est sa limite structurelle : si l'objet A référence l'objet B, et que B référence A en retour, alors même quand plus rien d'extérieur ne référence ni A ni B, chacun garde encore une référence vers l'autre. Leurs compteurs respectifs ne descendent jamais à zéro. Un cycle de deux objets, dix objets, ou une structure arborescente où chaque enfant garde un pointeur vers son parent — dans tous les cas, le refcount seul est structurellement incapable de les libérer, aussi orphelins soient-ils du reste du programme.The surprise isn't that refcount works well — the previous chapter showed it works remarkably well, for the most common case. The surprise is its structural limit: if object A references object B, and B references A back, then even when nothing external references either A or B anymore, each still holds a reference to the other. Their respective counts never drop to zero. A cycle of two objects, ten objects, or a tree structure where every child holds a pointer back to its parent — in every case, refcount alone is structurally incapable of freeing them, no matter how orphaned they are from the rest of the program.

Le refcount fonctionne exactement comme attendu iciRefcount works exactly as expected here
class Fichier:
    def __init__(self, nom):
        self.nom = nom
    def __del__(self):
        print(f"{self.nom} libéré")

def traiter():
    f = Fichier("rapport.csv")
    print("traitement...")
    # f n'a qu'UNE seule référence : la variable locale f

traiter()
# affiche :
# traitement...
# rapport.csv libéré     <- immédiatement à la fin de traiter(), quand
#                            la variable locale f sort de portée et que
#                            le refcount de l'objet Fichier tombe à zéro
№ 03La mécaniqueThe mechanics5 min

Un second ramasse-miettes, seulement pour les cycles, scanne périodiquement les conteneurs — jamais les entiers ni les chaînes.A second garbage collector, only for cycles, periodically scans containers — never integers or strings.

CPython ne s'arrête pas au refcount : le module gc implémente un second mécanisme, le ramasse-miettes de cycles, spécifiquement conçu pour détecter et casser les références circulaires que le comptage seul ne peut pas voir. Il ne scanne que les objets capables de participer à un cycle — listes, dictionnaires, instances de classes définies par l'utilisateur — jamais les entiers, chaînes ou tuples immuables sans conteneur interne, qui structurellement ne peuvent référencer eux-mêmes en retour. Ces objets sont organisés en trois générations : gen0 rassemble les objets récents, scannée fréquemment ; un objet qui survit à un passage est promu vers gen1 puis gen2, scannées de plus en plus rarement, sur l'hypothèse — vérifiée empiriquement — que la plupart des objets meurent jeunes.CPython doesn't stop at refcount: the gc module implements a second mechanism, the cyclic garbage collector, specifically designed to detect and break the circular references that counting alone can't see. It only scans objects capable of participating in a cycle — lists, dicts, instances of user-defined classes — never integers, strings, or container-free immutable tuples, which structurally can't reference themselves back. These objects are organized into three generations: gen0 gathers recent objects, scanned frequently; an object that survives a pass gets promoted to gen1 then gen2, scanned less and less often, on the assumption — empirically verified — that most objects die young.

gc.collect() casse manuellement le cycle du chapitre précédentgc.collect() manually breaks the previous chapter's cycle
import gc

class Noeud:
    def __init__(self, nom):
        self.nom = nom
        self.parent = None
    def __del__(self):
        print(f"{self.nom} libéré")

def creer_cycle():
    a = Noeud("A")
    b = Noeud("B")
    a.parent = b
    b.parent = a

creer_cycle()
print("après creer_cycle() : silence, comme au chapitre précédent")

gc.collect()   # force un passage du ramasse-miettes DE CYCLES
# affiche maintenant :
# A libéré
# B libéré
# -- le module gc a détecté le cycle et l'a cassé lui-même
Trois générations, scannées de moins en moins souventThree generations, scanned less and less often
import gc

print(gc.get_threshold())
# (2000, 10, 10) en CPython 3.14 -- (700, 10, 10) jusqu'à 3.13
# gen0 est scannée après ~2000 allocations nettes de conteneurs
# (list, dict, objets définis par l'utilisateur -- pas int, pas str,
# qui ne PEUVENT pas participer à un cycle et ne sont jamais scannés)
# un objet qui survit à un passage monte à la génération suivante --
# gen1, gen2 sont scannées moins souvent : l'hypothèse est que la
# plupart des objets meurent jeunes (comme au chapitre précédent),
# donc scanner les vieux objets à chaque fois serait du gaspillage
Ce qui distingue les deux mécanismesWhat sets the two mechanisms apart

Le refcount libère de façon déterministe et immédiate, dès qu'un objet devient inatteignable seul. Le gc de cycles libère de façon différée, au gré des seuils, à un passage de scan dont le moment exact n'est pas garanti par le code lui-même. Un objet dans un cycle peut donc rester en mémoire bien après être devenu logiquement inutile.Refcount releases deterministically and immediately, as soon as an object becomes unreachable on its own. The cyclic gc releases deferredly, as thresholds are crossed, at a scan pass whose exact timing isn't guaranteed by the code itself. An object caught in a cycle can therefore stay in memory well after becoming logically useless.

№ 04Le piègeThe trap4 min

Un lien parent-enfant en apparence anodin peut faire gonfler la mémoire bien au-delà de ce que le code laisse deviner.A seemingly harmless parent-child link can bloat memory far beyond what the code suggests.

Le piège n'est pas théorique : un pattern parent-enfant très courant — un widget qui garde une référence vers son parent en plus des références de son parent vers ses enfants — crée un cycle à chaque instanciation. Depuis Python 3.4, le ramasse-miettes de cycles sait parfaitement casser ces cycles même en présence de __del__ ; le problème n'est donc plus l'incapacité à les libérer un jour, mais le délai. Tant qu'un passage de scan n'a pas eu lieu, chaque objet du cycle — et tout ce qu'il retient, y compris de gros buffers de données — reste en mémoire, alors même que le programme n'y a plus aucun accès utile. Sur une boucle qui crée et abandonne ce genre de structure en rafale, la mémoire résidente peut grimper très au-delà de ce que le code, lu seul, laisse deviner.The trap isn't theoretical: a very common parent-child pattern — a widget that keeps a reference to its parent in addition to its parent's references to its children — creates a cycle on every instantiation. Since Python 3.4, the cyclic garbage collector perfectly knows how to break these cycles even in the presence of __del__; the problem is no longer the inability to ever free them, but the delay. Until a scan pass has occurred, every object in the cycle — and everything it holds, including large data buffers — stays in memory, even though the program no longer has any useful access to it. On a loop that creates and abandons this kind of structure in bursts, resident memory can climb far beyond what the code, read alone, suggests.

Chaque widget crée un cycle ; la libération attend le gc de cyclesEvery widget creates a cycle; release waits on the cyclic gc
class Widget:
    def __init__(self, nom, parent=None):
        self.nom = nom
        self.parent = parent          # référence forte vers le parent
        self.enfants = []
        self.gros_buffer = bytearray(10_000_000)   # 10 Mo par widget
        if parent:
            parent.enfants.append(self)   # le parent référence l'enfant EN RETOUR

def construire_arbre_temporaire():
    racine = Widget("fenêtre")
    for i in range(20):
        Widget(f"panneau_{i}", parent=racine)   # 20 cycles racine <-> enfant
    return None   # racine sort de portée -- mais chaque Widget est
                   # dans un cycle (parent <-> enfants), refcount ne
                   # libère RIEN -- 200+ Mo attendent le prochain passage
                   # du ramasse-miettes de cycles, dont le moment n'est
                   # pas garanti par le code

for _ in range(50):
    construire_arbre_temporaire()
# la mémoire résidente peut grimper à plus d'un gigaoctet avant qu'un
# passage de gen2 ne finisse par tout libérer d'un coup
Le réflexe à retenirThe reflex to keep

Un lien de retour (enfant vers parent, observateur vers sujet, cache vers propriétaire) est presque toujours candidat à weakref : il n'a besoin de dire « qui possède qui », jamais de participer au décompte qui décide quand libérer la mémoire.A back-link (child to parent, observer to subject, cache to owner) is almost always a weakref candidate: it only needs to say 'who owns whom', never to participate in the count that decides when to free memory.

№ 05Bilan & éditoRecap & editorial2 min

Ce numéro en une tableThis issue in one table

№No.TitreTitleTensionTension
25Comptage de références & cyclesReference counting & cyclesrefcount libère immédiatement ; un cycle attend le ramasse-miettes, weakref le romptrefcount frees immediately; a cycle waits on the garbage collector, weakref breaks it
Chaque objet Python porte son propre compte à rebours. Deux objets qui se tiennent la main peuvent le faire tourner indéfiniment, sans qu'aucun des deux n'ait rien fait de mal.Every Python object carries its own countdown. Two objects holding each other's hand can keep it running forever, without either one having done anything wrong.
Prochain numéro — №26Next issue — No. 26

Ce numéro a montré que chaque objet porte un compteur qui décide de sa mort. Le №26 remonte encore plus loin : que coûte le simple fait que « tout, en Python, soit un objet » ? Pourquoi a is b semble « marcher » pour de petits entiers comme 256, et se brise dès 257 — et pourquoi ce n'est jamais une coïncidence.This issue showed that every object carries a counter deciding its death. No. 26 goes even further back: what does it cost that, in Python, "everything is an object"? Why does a is b seem to "work" for small integers like 256, and break as soon as 257 — and why that's never a coincidence.