Les dunders sont le protocole : len(x) appelle x.__len__() The dunders are the protocol: len(x) calls x.__len__()

Le vrai pouvoir de Python n'est pas dans les méthodes que tu nommes, mais dans celles qu'il appelle pour toi. len(x) exécute x.__len__(), x[k] exécute x.__getitem__(k), a + b exécute a.__add__(b). Implémente les bonnes méthodes spéciales, et ton objet se fond dans la syntaxe du langage — pas par héritage, par le modèle de données. Le prix : chaque dunder t'engage à un contrat que le langage suppose tenu. Python's real power isn't in the methods you name, but in the ones it calls for you. len(x) runs x.__len__(), x[k] runs x.__getitem__(k), a + b runs a.__add__(b). Implement the right special methods, and your object melts into the language's syntax — not by inheritance, by the data model. The price: each dunder commits you to a contract the language assumes is upheld.

Audience
Dev qui veut que ses objets se comportent comme des types natifs Dev who wants their objects to behave like native types
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

Data modelDundersProtocoles

SommaireContents ·
№ 01CadrageFraming3 min

len, [], for, + ne sont pas des primitives — ce sont des appels de dunders.len, [], for, + aren't primitives — they're dunder calls.

Le numéro précédent parlait des méthodes que tu nommes : source.read(). Voici l'autre moitié du protocole, la plus puissante — les méthodes que Python appelle pour toi, sans que tu les écrives explicitement. len(p) n'est pas une fonction qui radiographie p : c'est un raccourci pour p.__len__(). De même x[k] appelle __getitem__, a + b appelle __add__, for … in x appelle __iter__. Ces méthodes à double underscore — les « dunders » — sont les points d'ancrage du modèle de données. Les implémenter, c'est brancher ton objet directement sur la syntaxe du langage.The previous issue was about methods you name: source.read(). Here's the other half of the protocol, the more powerful one — the methods Python calls for you, without you writing them explicitly. len(p) isn't a function that X-rays p: it's shorthand for p.__len__(). Likewise x[k] calls __getitem__, a + b calls __add__, for … in x calls __iter__. These double-underscore methods — the 'dunders' — are the data model's anchor points. Implementing them wires your object straight into the language's syntax.

Un dunder, et len() fonctionne sur ton objetOne dunder, and len() works on your object
class Panier:
    def __init__(self, articles):
        self.articles = articles
    def __len__(self):                 # une méthode « spéciale »
        return len(self.articles)

p = Panier(["pomme", "pain"])
print(len(p))          # 2 — len(p) n'a pas inspecté p : il a appelé p.__len__()
if p:                  # « le panier est-il non vide ? »
    print("non vide")  # vrai — sans __bool__, Python retombe sur __len__
La syntaxe délègue à une méthodeSyntax delegates to a method
len(x)→x.__len__()
x[k]→x.__getitem__(k)
a + b→a.__add__(b)
for i in x→x.__iter__()
x == y→x.__eq__(y)

Chaque bout de syntaxe « magique » de Python est, en dessous, un appel à une méthode que tu peux définir. Le langage ne réserve pas ces pouvoirs à ses types natifs — il te donne les mêmes crochets.Every piece of Python's "magic" syntax is, underneath, a call to a method you can define. The language doesn't reserve these powers for its native types — it hands you the same hooks.

Le sous-réflexe du numéroThis issue's sub-reflex

Quand tu veux qu'un objet « se comporte comme » une liste, un nombre, un fichier, ne cherche pas une classe de base à hériter. Demande : quelle syntaxe dois-je supporter, et quel dunder chaque syntaxe appelle-t-elle ? Implémente ces dunders, et l'objet parle nativement la langue.When you want an object to "behave like" a list, a number, a file, don't look for a base class to inherit. Ask: which syntax must I support, and which dunder does each syntax call? Implement those dunders, and the object speaks the language natively.

Le modèle de données, pas l'héritage.The data model, not inheritance.

Dans un langage nominal, « être une séquence » veut dire hériter d'une interface Sequence. En Python, ça veut dire répondre à __len__ et __getitem__. La liste, la chaîne, le tuple ne partagent pas une classe de base commune riche : ils partagent un jeu de dunders. Ton objet entre dans la même famille par les mêmes méthodes, sans lien de parenté.In a nominal language, 'being a sequence' means inheriting a Sequence interface. In Python, it means answering __len__ and __getitem__. The list, the string, the tuple don't share a rich common base class: they share a set of dunders. Your object joins the same family through the same methods, with no kinship.

№ 02La surpriseThe surprise4 min

Deux dunders, et tu débloques une demi-douzaine de syntaxes.Two dunders, and you unlock half a dozen syntaxes.

Le rendement des dunders est disproportionné : une poignée de méthodes, et des pans entiers de la syntaxe s'allument d'un coup. Implémente __len__ et __getitem__, et ton objet ne gagne pas seulement l'indexation d[0] : il gagne l'appartenance (in), l'itération (for), et reversed() — parce que Python construit ces opérations par-dessus les mêmes crochets. Implémente __eq__ et __add__, et == et + fonctionnent, y compris quand ton objet est rangé dans une liste. Tu ne codes pas des fonctionnalités isolées ; tu remplis un modèle qui, lui, sait recomposer le reste.The return on dunders is disproportionate: a handful of methods, and whole swaths of syntax light up at once. Implement __len__ and __getitem__, and your object gains not only indexing d[0]: it gains membership (in), iteration (for), and reversed() — because Python builds those operations on top of the same hooks. Implement __eq__ and __add__, and == and + work, even when your object sits in a list. You're not coding isolated features; you're filling a model that recomposes the rest for you.

Un objet qui devient une séquenceAn object that becomes a sequence
class Deck:
    def __init__(self, cartes): self.cartes = cartes
    def __len__(self):          return len(self.cartes)
    def __getitem__(self, i):   return self.cartes[i]

d = Deck(["A", "K", "Q"])
print(d[0])                 # 'A'         — indexation
print("K" in d)             # True        — appartenance, gratuite
for c in d:  ...            #             — itération, gratuite (fallback __getitem__)
print(list(reversed(d)))    # ['Q','K','A'] — reversed, gratuite

Tu n'as écrit que __len__ et __getitem__. Pourtant in, for et reversed() marchent : faute d'__iter__ dédié, Python sait itérer par indices — appeler __getitem__(0), (1), … jusqu'à IndexError. Un dunder en nourrit plusieurs : le modèle de données recompose les opérations de haut niveau à partir des primitives que tu fournis.You only wrote __len__ and __getitem__. Yet in, for and reversed() work: lacking a dedicated __iter__, Python knows how to iterate by index — call __getitem__(0), (1), … until IndexError. One dunder feeds several: the data model recomposes high-level operations from the primitives you provide.

Tu n'ajoutes pas des méthodes à un objet. Tu remplis les cases d'un modèle — et le langage recompose la syntaxe autour.You're not adding methods to an object. You're filling a model's slots — and the language recomposes the syntax around them.
№ 03La mécaniqueThe mechanics5 min

Les dunders sont cherchés sur le type, pas sur l'instance.Dunders are looked up on the type, not the instance.

Deux règles gouvernent l'appel implicite d'un dunder, et la seconde surprend tout le monde. La première : chaque syntaxe se désucre en un appel de méthode spéciale — len(x) devient type(x).__len__(x). La seconde, moins connue : pour ces appels implicites, Python cherche le dunder sur le type de l'objet, jamais dans le dictionnaire de l'instance. Poser x.__len__ sur une instance ne change pas ce que len(x) fait. C'est une optimisation du modèle — et la raison pour laquelle les méthodes spéciales se définissent toujours au niveau de la classe.Two rules govern a dunder's implicit call, and the second surprises everyone. First: each syntax desugars into a special-method call — len(x) becomes type(x).__len__(x). Second, less known: for these implicit calls, Python looks up the dunder on the object's type, never in the instance's dict. Setting x.__len__ on an instance doesn't change what len(x) does. It's a model optimization — and the reason special methods are always defined at the class level.

Chaque syntaxe = un appel de méthode spécialeEach syntax = a special-method call
# La syntaxe, désucrée en appels de dunders sur le TYPE :
len(x)         # ->  type(x).__len__(x)
x[k]           # ->  type(x).__getitem__(x, k)
a + b          # ->  type(a).__add__(a, b)
str(x)         # ->  type(x).__str__(x)
x()            # ->  type(x).__call__(x)

Il n'y a rien de magique : len, str, les crochets, les opérateurs, même l'appel x() sont des façades sur des dunders. Cela explique pourquoi tu peux tout redéfinir — et pourquoi une bibliothèque comme NumPy peut faire de a + b une addition vectorielle : elle fournit __add__. La syntaxe est une couche mince ; le comportement vit dans les méthodes. (L'itération, for, a sa propre mécanique — Vol. IV.)There's nothing magic: len, str, the brackets, the operators, even the call x() are façades over dunders. That's why you can redefine everything — and why a library like NumPy can make a + b a vector addition: it supplies __add__. Syntax is a thin layer; behavior lives in the methods. (Iteration, for, has its own mechanics — Vol. IV.)

Le réflexe en une ligneThe reflex in one line

La syntaxe appelle type(x).__dunder__(x, …), jamais x.__dunder__ posé sur l'instance. Définis tes méthodes spéciales sur la classe — c'est le seul endroit que le langage regarde.Syntax calls type(x).__dunder__(x, …), never an x.__dunder__ set on the instance. Define your special methods on the class — the only place the language looks.

№ 04Le piègeThe trap4 min

Un dunder est un contrat. En signer un, c'est s'engager sur les autres.A dunder is a contract. Signing one commits you to the others.

Le pouvoir des dunders a une contrepartie : le langage suppose que tu honores leurs contrats, et il ne les vérifie pas. Définir __eq__ sans __hash__ met silencieusement __hash__ à None — ton objet devient non hachable, éjecté des sets et des clés de dict, alors que tu voulais juste comparer. Un __getitem__ qui ne lève jamais IndexError transforme un for en boucle infinie. Un __add__ qui plante au lieu de renvoyer NotImplemented casse la symétrie a + b. Chaque méthode spéciale a des attentes que d'autres dunders, d'autres syntaxes, tiennent pour acquises.The power of dunders has a flip side: the language assumes you honor their contracts, and it doesn't check them. Defining __eq__ without __hash__ silently sets __hash__ to None — your object becomes unhashable, evicted from sets and dict keys, when you only wanted to compare. A __getitem__ that never raises IndexError turns a for into an infinite loop. An __add__ that crashes instead of returning NotImplemented breaks the symmetry of a + b. Each special method has expectations other dunders, other syntaxes, take for granted.

__eq__ seul retire l'objet des sets et des dicts__eq__ alone evicts the object from sets and dicts
class Point:
    def __init__(self, x, y): self.x, self.y = x, y
    def __eq__(self, o):
        return (self.x, self.y) == (o.x, o.y)
    # définir __eq__ sans __hash__ met __hash__ à None, automatiquement

p = Point(1, 2)
vus = {p}          # TypeError: unhashable type: 'Point'
# en donnant __eq__, tu as tacitement retiré Point des sets et des clés de dict

Le langage relie __eq__ et __hash__ : deux objets égaux doivent avoir le même hash, donc redéfinir l'égalité invalide le hash par défaut. Python te protège d'une incohérence… en supprimant le hash, ce qui casse un usage courant. Tu n'as pas « juste ajouté == » : tu as touché à un contrat couplé. C'est exactement le sujet du prochain numéro, le pacte __hash__/__eq__.The language ties __eq__ and __hash__: two equal objects must share the same hash, so redefining equality invalidates the default hash. Python shields you from an inconsistency… by removing the hash, which breaks a common use. You didn't "just add ==": you touched a coupled contract. That's precisely the next issue's subject, the __hash__/__eq__ pact.

Le contre-emploi : trop de magieThe counter-use: too much magic

Pouvoir surcharger une syntaxe ne veut pas dire qu'on le doit. Un __add__ qui « additionne » deux comptes bancaires, un + qui concatène des chemins, un objet qui redéfinit __getattr__ pour tout accepter : la syntaxe devient jolie, le sens devient flou. La règle de goût : n'implémente un dunder que si l'opération qu'il représente est évidente pour ton type. Sinon, une méthode nommée dit mieux l'intention.Being able to overload a syntax doesn't mean you should. An __add__ that "adds" two bank accounts, a + that concatenates paths, an object redefining __getattr__ to accept anything: the syntax gets pretty, the meaning gets blurry. The taste rule: implement a dunder only if the operation it represents is obvious for your type. Otherwise, a named method states the intent better.

Le langage ne relit pas ton contrat.The language won't proofread your contract.

Rien ne vérifie qu'un __eq__ est réflexif, qu'un __lt__ est cohérent avec __eq__, qu'un __repr__ ne ment pas. Ces invariants sont supposés par le tri, les sets, le débogage. Les rompre ne lève pas d'erreur : ça produit un comportement faux, tard, ailleurs. C'est le coût du dynamisme, encore — la discipline remplace le vérificateur.Nothing checks that an __eq__ is reflexive, that an __lt__ agrees with __eq__, that a __repr__ doesn't lie. These invariants are assumed by sorting, sets, debugging. Breaking them raises no error: it produces wrong behavior, late, elsewhere. It's the cost of dynamism again — discipline replaces the checker.

Implémenter un dunder, c'est promettre au langage un comportement qu'il n'ira jamais vérifier. La syntaxe, en échange, te croit sur parole.To implement a dunder is to promise the language a behavior it will never verify. The syntax, in return, takes you at your word.
№ 05Bilan & éditoWrap-up & editorial2 min

Le catalogue des dunders : quelle syntaxe, quelle promesse.The dunder catalogue: which syntax, which promise.

Les méthodes spéciales sont l'envers du duck typing : là où le №07 exigeait des comportements que tu nommes, le modèle de données définit les comportements que la syntaxe nomme pour toi. Remplis les bonnes cases, et ton objet s'indexe, s'itère, s'additionne, se compare comme un natif — sans héritage. Mais chaque case est un contrat : le langage l'appelle, il ne le vérifie pas.Special methods are the flip side of duck typing: where №07 demanded behaviors you name, the data model defines the behaviors the syntax names for you. Fill the right slots, and your object indexes, iterates, adds, compares like a native — without inheritance. But each slot is a contract: the language calls it, it doesn't check it.

La syntaxeThe syntaxLe dunder appeléThe dunder calledLa promesse à tenirThe promise to keep
len(x), if x:__len__ (défaut de(fallback of __bool__)Rendre un entier ≥ 0. len == 0 rend l'objet « falsy ».Return an int ≥ 0. len == 0 makes the object falsy.
x[k], for, in__getitem__ / __iter__Lever IndexError hors bornes, sinon l'itération ne s'arrête jamais (Vol. IV).Raise IndexError out of bounds, else iteration never stops (Vol. IV).
a + b, a == b__add__ / __eq__Renvoyer NotImplemented pour un type inconnu ; __eq__ entraîne __hash__ (№09).Return NotImplemented for an unknown type; __eq__ drags __hash__ (№09).
str(x), repr(x)__str__ / __repr__repr doit être sans ambiguïté (idéalement recréable) ; ne pas mentir sur l'état.repr should be unambiguous (ideally re-creatable); don't lie about state.
Tout d'un blocAll in one block@dataclass(frozen=True)Génère init, repr, eq et hash cohérents. Le premier réflexe pour un objet-valeur.Generates consistent init, repr, eq and hash. The first reflex for a value object.
Un objet Python n'« est » pas d'une classe. Il est la somme des dunders auxquels il répond.A Python object doesn't "belong to" a class. It is the sum of the dunders it answers.
Mot de l'éditeurFrom the editor

La syntaxe n'est pas au-dessus de tes objets. Elle passe par eux.Syntax isn't above your objects. It runs through them.

Dans beaucoup de langages, la syntaxe est un privilège du cœur : + est câblé pour les nombres, [] pour les tableaux, et tes classes n'y accèdent qu'en imitant maladroitement. Python renverse la scène. Il n'y a presque pas d'opération native : il y a des dunders, et la syntaxe n'est qu'une façade qui les appelle. Tes objets ne singent pas les types du langage — ils jouent au même niveau, par les mêmes crochets. C'est vertigineux de puissance, et c'est le même contrat que partout dans ce volume : le langage t'ouvre son modèle et te fait confiance pour en respecter les règles tacites. Il t'appelle ; il ne te relit pas.In many languages, syntax is a privilege of the core: + is wired for numbers, [] for arrays, and your classes only reach it by clumsy imitation. Python flips the scene. There's almost no native operation: there are dunders, and syntax is just a façade calling them. Your objects don't ape the language's types — they play at the same level, through the same hooks. It's dizzying in power, and it's the same contract as everywhere in this volume: the language opens its model to you and trusts you to respect its tacit rules. It calls you; it doesn't proofread you.

Prochain numéro : le pacte __hash__ / __eq__. On l'a effleuré ici — définir l'égalité touche au hachage. On va disséquer pourquoi : les clés de dict et les éléments de set reposent sur une règle non négociable — deux objets égaux doivent avoir le même hash — et sur l'objet qu'on ne doit jamais hacher, celui qui mute. Le contrat qui fait tenir les structures les plus utilisées de Python.Next issue: the __hash__ / __eq__ pact. We brushed it here — defining equality touches hashing. We'll dissect why: dict keys and set elements rest on a non-negotiable rule — two equal objects must have the same hash — and on the object you must never hash, the one that mutates. The contract that holds up Python's most-used structures.