Duck typing : un objet est ce qu'il sait faire Duck typing: an object is what it can do

« If it walks like a duck and quacks like a duck, it's a duck. » En Python, une fonction ne devrait pas demander de quelle classe tu hérites, mais si tu réponds à l'appel qu'elle va te passer. L'interface appartient au consommateur : implémente les bonnes méthodes, et tu satisfais le protocole sans rien déclarer. Le prix : aucun compilateur ne vérifie ce contrat — il te reste l'AttributeError, au runtime, loin de la faute. 'If it walks like a duck and quacks like a duck, it's a duck.' In Python, a function shouldn't ask which class you inherit from, but whether you answer the call it's about to make. The interface belongs to the consumer: implement the right methods, and you satisfy the protocol without declaring anything. The price: no compiler checks that contract — you're left with AttributeError, at runtime, far from the fault.

Audience
Dev d'un langage à interfaces nominales (Java, C#, Go, TS) découvrant le structurel Dev from a nominal-interface language (Java, C#, Go, TS) meeting structural typing
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●○○
Date
Juil 2026 Jul 2026

Duck typingProtocolesInterfaces

SommaireContents ·
№ 01CadrageFraming3 min

Ne demande pas « de quoi hérites-tu ? ». Demande « sais-tu faire ça ? ».Don't ask "what do you inherit from?". Ask "can you do this?".

Nouveau volume, nouvel axe. Les deux premiers demandaient « quel objet, et qui d'autre le tient ? ». Celui-ci demande autre chose : « que sait faire cet objet ? ». En Python, une fonction n'a pas besoin de savoir de quelle classe descend son argument. Elle a besoin qu'il réponde aux appels qu'elle va lui passer. lire_tout ne réclame ni un File, ni une sous-classe de quoi que ce soit : elle appelle .read(), point. Un fichier, un flux mémoire, un objet maison — tout ce qui a une méthode read() convient. L'interface n'est écrite nulle part ; elle est définie, en creux, par ce que la fonction utilise.New volume, new axis. The first two asked 'which object, and who else holds it?'. This one asks something else: 'what can this object do?'. In Python, a function needn't know which class its argument descends from. It needs the argument to answer the calls it's about to make. lire_tout demands neither a File, nor a subclass of anything: it calls .read(), full stop. A file, a memory stream, a home-made object — anything with a read() method fits. The interface is written nowhere; it's defined, in hollow, by what the function uses.

Une fonction, trois types sans lien de parentéOne function, three unrelated types
def lire_tout(source):
    return source.read()          # on ne demande qu'UN comportement : .read()

lire_tout(open("data.txt"))       # un fichier — marche
import io
lire_tout(io.StringIO("salut"))   # un flux en mémoire — marche aussi
# aucune classe commune, aucune déclaration : juste .read() qui répond présent
L'interface appartient à l'appelantThe interface belongs to the caller
File
StringIO
MonObjet
.read()
⟶
suffitis enough
lire_tout(source)
ne voit qu'un comportementsees only a behavior

Le protocole « lisible » n'est déclaré par personne. Il existe parce qu'une fonction l'utilise. Tout objet qui répond à .read() le remplit — sans le savoir, sans hériter de rien.The "readable" protocol is declared by no one. It exists because a function uses it. Any object that answers .read() fulfills it — unknowingly, inheriting nothing.

Le réflexe du volumeThe volume's reflex

« Que demande l'appelant — pas de quelle classe hérite le type ? » Quand tu écris une fonction, liste les méthodes que tu appelles sur ton paramètre, pas les types que tu imagines recevoir. Ce sont ces méthodes, et elles seules, qui forment ton vrai contrat."What does the caller need — not which class the type inherits from?" When you write a function, list the methods you call on your parameter, not the types you imagine receiving. Those methods, and only those, form your real contract.

Nominal contre structurel.Nominal versus structural.

Venu de Java, Go ou TypeScript, tu connais l'interface nominale : un type doit déclarer « j'implémente Readable » pour être accepté. Python fait du typage structurel de fait : tu es « lisible » si tu as read(), que tu l'aies annoncé ou non. L'appartenance ne se déclare pas ; elle se constate à l'usage.Coming from Java, Go or TypeScript, you know nominal interfaces: a type must declare 'I implement Readable' to be accepted. Python does de-facto structural typing: you're 'readable' if you have read(), whether you announced it or not. Membership isn't declared; it's observed in use.

№ 02La surpriseThe surprise4 min

isinstance ferme sur un type. Le duck typing ouvre sur un comportement.isinstance closes on a type. Duck typing opens on a behavior.

Le réflexe hérité d'un langage nominal, c'est de « sécuriser » une fonction en vérifiant le type de l'entrée. Mais isinstance(x, list) ne demande pas « sais-tu faire ce dont j'ai besoin ? » — il demande « es-tu précisément de cette classe ? ». Il rejette donc des objets qui marcheraient très bien : un tuple, un set, un range, un générateur, tous sommables, tous itérables. Le duck typing fait l'inverse : il n'interroge pas le type, il tente le comportement. Ce qui répond passe ; ce qui ne répond pas échoue de lui-même, là où le comportement manque.The reflex inherited from a nominal language is to 'secure' a function by checking the input's type. But isinstance(x, list) doesn't ask 'can you do what I need?' — it asks 'are you exactly this class?'. So it rejects objects that would work perfectly: a tuple, a set, a range, a generator, all summable, all iterable. Duck typing does the opposite: it doesn't interrogate the type, it attempts the behavior. What answers passes; what doesn't fails on its own, where the behavior is missing.

Vérifier le type rejette des entrées validesChecking the type rejects valid inputs
def moyenne(nombres):
    if not isinstance(nombres, list):     # « je n'accepte QUE des listes »
        raise TypeError("liste attendue")
    return sum(nombres) / len(nombres)

moyenne([1, 2, 3])       # 2.0
moyenne((1, 2, 3))       # TypeError — un tuple, pourtant parfaitement sommable

La garde isinstance(nombres, list) croit protéger la fonction ; en réalité elle la rétrécit. Un tuple se somme et se compte exactement comme une liste, mais il est refusé pour un motif qui n'a rien à voir avec ce dont moyenne a besoin : sa classe. Tu n'as pas validé une capacité, tu as exclu une famille. Le code devient rigide sans devenir plus sûr.The guard isinstance(nombres, list) thinks it protects the function; in reality it narrows it. A tuple sums and counts exactly like a list, yet it's refused for a reason unrelated to what moyenne needs: its class. You didn't validate a capability, you excluded a family. The code turns rigid without turning safer.

Vérifier le type, c'est répondre à une question que tu ne poses pas. La vraie question n'est jamais « quelle classe ? », c'est « quel comportement ? ».Checking the type answers a question you're not asking. The real question is never "which class?", it's "which behavior?".
№ 03La mécaniqueThe mechanics5 min

Il n'y a pas d'interface à vérifier — seulement une méthode à trouver, au moment de l'appel.There's no interface to check — only a method to find, at call time.

Sous le duck typing, la mécanique est nue : quand tu écris source.read(), Python ne consulte aucune déclaration. Il fait une recherche d'attribut sur l'objet, à l'instant de l'appel ; s'il trouve read, il l'appelle ; sinon, il lève AttributeError. Le « protocole » n'existe pas comme entité — il n'est que la somme des recherches qui réussissent. D'où deux styles pour s'y fier. LBYL (look before you leap) demande d'abord hasattr, puis appelle. EAFP (easier to ask forgiveness) appelle directement et rattrape l'échec. En Python, le second est l'idiome — et on verra pourquoi le premier ment parfois.Under duck typing, the mechanics are bare: when you write source.read(), Python consults no declaration. It performs an attribute lookup on the object, at the instant of the call; if it finds read, it calls it; otherwise, it raises AttributeError. The 'protocol' doesn't exist as an entity — it's just the sum of the lookups that succeed. Hence two styles for relying on it. LBYL (look before you leap) asks hasattr first, then calls. EAFP (easier to ask forgiveness) calls directly and catches the failure. In Python, the second is the idiom — and we'll see why the first sometimes lies.

Appeler, et traduire l'échec — l'idiome PythonCall, and translate the failure — the Python idiom
def lire(source):
    try:
        return source.read()         # EAFP : j'essaie, je rattrape l'échec
    except AttributeError:
        raise TypeError("source illisible") from None
# une seule recherche ; le protocole se vérifie en s'exerçant

EAFP tente l'appel et n'attrape que ce qui signale l'absence du comportement : AttributeError — avec une nuance : un AttributeError levé à l'intérieur de read() serait rattrapé aussi ; garde le try aussi court que possible. Une seule recherche, et le test coïncide avec l'usage — impossible de valider puis de casser. Le from None masque la chaîne d'exceptions interne pour ne montrer que ton message. « Essaie, et sois précis sur ce que tu rattrapes » est la façon idiomatique d'exiger un protocole. (Le style EAFP, comme flux de contrôle, a son propre numéro — Vol. VII, № 20.)EAFP attempts the call and catches only what signals the missing behavior: AttributeError — with one caveat: an AttributeError raised inside read() would be caught too; keep the try as short as possible. A single lookup, and the test coincides with the use — impossible to validate then break. The from None hides the internal exception chain to show only your message. "Try, and be precise about what you catch" is the idiomatic way to demand a protocol. (EAFP as control flow has its own issue — Vol. VII, № 20.)

Le réflexe en une ligneThe reflex in one line

Le protocole n'est pas déclaré, il est cherché à l'appel. Alors ne demande pas « as-tu la méthode ? » : appelle-la, et rattrape précisément l'absence. Exercer le comportement est le test.The protocol isn't declared, it's looked up at the call. So don't ask "do you have the method?": call it, and catch the absence precisely. Exercising the behavior is the test.

№ 04Le piègeThe trap4 min

Deux méthodes de même nom, un sens opposé — et aucun compilateur pour le voir.Two methods, same name, opposite meaning — and no compiler to see it.

La souplesse a un prix, et il se paie à deux endroits. D'abord, le duck typing ne distingue pas deux méthodes qui portent le même nom mais veulent dire des choses différentes : si ton .write attendu écrit sur disque et que l'objet reçu a un .write qui journalise, l'appel réussit et ne fait pas ce que tu crois. Ensuite, quand une méthode manque vraiment, l'AttributeError ne surgit pas à la frontière fautive : elle éclate au fond de la pile, loin de l'appelant qui a passé le mauvais objet. Là où un langage nominal refusait de compiler, Python exécute — et te laisse découvrir le contrat au runtime.Flexibility has a price, paid in two places. First, duck typing doesn't tell apart two methods that share a name but mean different things: if your expected .write writes to disk and the received object has a .write that logs, the call succeeds and doesn't do what you think. Second, when a method truly is missing, the AttributeError doesn't surface at the offending boundary: it bursts deep in the stack, far from the caller who passed the wrong object. Where a nominal language refused to compile, Python runs — and lets you discover the contract at runtime.

Même nom, sens opposé — l'appel réussit à tortSame name, opposite meaning — the call wrongly succeeds
class Journal:
    def __init__(self): self.lignes = []
    def write(self, msg):
        self.lignes.append(msg)     # ici « write » veut dire : ajouter au journal

def sauver_sur_disque(fichier, data):
    fichier.write(data)             # attend un .write qui écrit un fichier

sauver_sur_disque(Journal(), "budget")
# aucune erreur. .write existe, la signature colle — mais rien n'atteint le disque.
# le duck typing ne voit pas que les deux write veulent dire des choses opposées

Journal et un fichier ont tous deux .write(str) — même nom, même signature, sens contraires. Le duck typing ne regarde que la forme : l'appel passe, et tes données partent dans un journal en mémoire au lieu du disque. Un protocole implicite ne capture qu'un nom et une arité, jamais une intention. Le silence est ici pire qu'une AttributeError : rien ne signale l'erreur.Journal and a file both have .write(str) — same name, same signature, opposite meanings. Duck typing looks only at shape: the call passes, and your data goes to an in-memory log instead of the disk. An implicit protocol captures only a name and an arity, never an intent. The silence here is worse than an AttributeError: nothing signals the mistake.

Quand vérifier le type est justeWhen checking the type is right

Le duck typing n'est pas un dogme anti-isinstance. Il y a des cas où le type est la bonne question : dispatcher un comportement selon la classe réelle (match sur des variants), refuser explicitement str là où l'on veut une liste de str (car str est aussi itérable, piège classique), ou coder une frontière de sérialisation. La règle : exige un comportement par défaut ; vérifie un type quand c'est vraiment le type qui compte.Duck typing isn't an anti-isinstance dogma. There are cases where the type is the right question: dispatching behavior on the real class (match on variants), explicitly refusing str where you want a list of str (since str is iterable too, a classic trap), or coding a serialization boundary. The rule: demand a behavior by default; check a type when the type is genuinely what matters.

L'erreur voyage loin de sa cause.The error travels far from its cause.

Sans vérification en amont, un mauvais objet traverse plusieurs fonctions avant que l'appel manquant ne lève. La trace pointe l'endroit du .read() absent, pas l'appelant fautif trois niveaux plus haut. Un Protocol (ou un test au bord) ramène l'erreur près de sa source — c'est tout ce qu'un compilateur t'offrait gratuitement.Without an upstream check, a bad object crosses several functions before the missing call raises. The traceback points at the absent .read(), not the offending caller three levels up. A Protocol (or a boundary check) brings the error back near its source — exactly what a compiler used to give you for free.

Le duck typing te croit sur parole. Un protocole implicite lit une forme, jamais une intention — et n'échoue qu'au moment de s'en servir.Duck typing takes you at your word. An implicit protocol reads a shape, never an intent — and fails only when it's used.
№ 05Bilan & éditoWrap-up & editorial2 min

Quatre réflexes pour exiger un comportement, pas un pedigree.Four reflexes to demand a behavior, not a pedigree.

En Python, un objet est ce qu'il sait faire. L'interface n'est pas déclarée sur le type, elle est réclamée par le consommateur : la fonction qui appelle .read() définit, à elle seule, ce que « lisible » veut dire. Cette inversion ouvre le code à des types qu'il ne connaîtra jamais — au prix d'un contrat qu'aucun compilateur ne tient à ta place. Le savoir, c'est choisir entre la souplesse nue et le filet d'un Protocol.In Python, an object is what it can do. The interface isn't declared on the type, it's demanded by the consumer: the function calling .read() alone defines what 'readable' means. This inversion opens the code to types it will never know — at the price of a contract no compiler holds for you. Knowing this is choosing between bare flexibility and a Protocol's net.

Tu veux…You want to…Le gesteThe moveCe que ça coûteWhat it costs
Accepter tout ce qui convientAccept all that fitsDuck typing : appelle la méthode dont tu as besoin, n'exige aucun type.Duck typing: call the method you need, demand no type.Aucun contrat écrit ; l'erreur, si elle vient, est une AttributeError au runtime, loin de la cause.No written contract; the error, if it comes, is a runtime AttributeError, far from its cause.
Exiger un protocoleDemand a protocolEAFP : try: x.m() except AttributeError. Une recherche, le test = l'usage.EAFP: try: x.m() except AttributeError. One lookup, test = use.hasattr en LBYL fait deux recherches et ment (attribut présent mais qui lève à l'appel).hasattr in LBYL does two lookups and lies (attribute present but raising on call).
La souplesse ET un filetFlexibility AND a nettyping.Protocol : déclare la forme, mypy vérifie structurellement, zéro héritage.typing.Protocol: declare the shape, mypy checks structurally, zero inheritance.Il faut annoter et lancer un vérificateur ; en échange, l'erreur revient au bord, avant l'exécution.You must annotate and run a checker; in return, the error returns to the boundary, before runtime.
Dispatcher sur le vrai typeDispatch on the real typeisinstance / match : quand c'est bien la classe qui décide du comportement.isinstance / match: when the class genuinely decides the behavior.À réserver aux vrais cas ; en garde d'entrée par réflexe, il rétrécit sans sécuriser.Reserve for true cases; as a reflex input guard, it narrows without securing.
Une fonction ne devrait jamais demander « qui es-tu ? ». Seulement « sais-tu faire ce que je vais te demander ? ».A function should never ask "who are you?". Only "can you do what I'm about to ask?".
Mot de l'éditeurFrom the editor

L'interface que personne n'a écrite.The interface no one wrote.

Dans un langage nominal, une interface est un objet du code : on la déclare, on l'implémente, le compilateur la fait respecter. En Python, elle n'existe pas — et pourtant elle gouverne tout. Chaque fonction définit, en creux, le protocole qu'elle exige, par les seules méthodes qu'elle appelle. C'est d'une souplesse folle : n'importe quel objet, présent ou à venir, du moment qu'il répond, entre dans le jeu. Mais cette interface fantôme, personne ne la maintient à ta place. Le contrat vit dans le corps des fonctions, pas dans une signature ; le tenir est ta discipline, ou celle de mypy. Simple, parce qu'il n'y a rien à déclarer. Pas facile, parce qu'il n'y a rien pour te rattraper.In a nominal language, an interface is an object in the code: you declare it, implement it, the compiler enforces it. In Python it doesn't exist — and yet it governs everything. Each function defines, in hollow, the protocol it demands, through the sole methods it calls. It's wildly flexible: any object, present or future, as long as it answers, joins the game. But this ghost interface, no one maintains it for you. The contract lives in the body of functions, not in a signature; holding it is your discipline, or mypy's. Simple, because there's nothing to declare. Not easy, because there's nothing to catch you.

Prochain numéro : les dunders sont le protocole. On a vu que Python appelle les méthodes que tu nommes ; le vrai pouvoir vient de celles qu'il appelle pour toi. len(x) exécute x.__len__(), for … in x exécute x.__iter__(), x == y exécute x.__eq__(y). 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.Next issue: the dunders are the protocol. We saw Python calls the methods you name; the real power comes from those it calls for you. len(x) runs x.__len__(), for … in x runs x.__iter__(), x == y runs x.__eq__(y). Implement the right special methods, and your object melts into the language's syntax — not by inheritance, by the data model.