Qu'est-ce que le duck typing en Python ?

Le duck typing est un principe de programmation selon lequel le type d'un objet importe moins que son comportement. En Python, si un objet possède les méthodes ou attributs nécessaires, il peut être utilisé sans vérification de type préalable. Le nom vient de l'expression : si ça marche comme un canard et que ça cancane comme un canard, c'est un canard. C'est ce qui permet à len() de fonctionner sur des listes, des chaînes et des dictionnaires sans lien d'héritage entre eux.

Quelle est la différence entre duck typing et héritage en Python ?

L'héritage garantit qu'une sous-classe est du même type que sa classe parente, et qu'elle dispose de toutes ses méthodes. Le duck typing ne nécessite pas de lien d'héritage : n'importe quel objet qui possède les bonnes méthodes peut être utilisé. Deux classes totalement indépendantes peuvent être utilisées de façon interchangeable si elles ont les mêmes méthodes. Le duck typing favorise la flexibilité ; l'héritage favorise la structure.

Qu'est-ce que EAFP en Python ?

EAFP signifie Easier to Ask Forgiveness than Permission. C'est le style idiomatique Python : on tente l'opération directement et on attrape l'exception si elle échoue, plutôt que de vérifier toutes les conditions avant d'agir (style LBYL, Look Before You Leap). Par exemple, plutôt que de vérifier si une clé existe dans un dictionnaire avant d'y accéder, on accède directement et on intercepte KeyError si nécessaire.

Faut-il éviter isinstance() avec le duck typing en Python ?

Non, isinstance() reste utile dans plusieurs cas : générer un message d'erreur explicite, adapter le comportement selon le type reçu, ou valider les paramètres d'une API publique. Le principe du duck typing n'interdit pas isinstance() — il déconseille de rejeter un objet uniquement parce qu'il n'hérite pas d'un type précis. Vérifier qu'un objet a bien __iter__ avec hasattr() est souvent plus flexible que vérifier isinstance(obj, list).

Qu'est-ce qu'un protocole Python ?

Un protocole Python est un ensemble de méthodes spéciales à implémenter pour qu'un objet soit compatible avec une fonctionnalité du langage. Implémenter __len__ rend un objet compatible avec len(). Implémenter __iter__ et __next__ le rend itérable dans une boucle for. Implémenter __enter__ et __exit__ le rend utilisable avec with. Les protocoles sont la formalisation du duck typing dans Python.

Comment rendre une classe itérable en Python ?

Implémentez les méthodes __iter__ et __next__ dans votre classe. __iter__ doit retourner l'objet lui-même (return self). __next__ doit retourner la valeur suivante à chaque appel et lever StopIteration quand il n'y a plus d'éléments. Une fois ces deux méthodes définies, votre objet fonctionne dans les boucles for, avec list(), sum(), min(), max() et toutes les fonctions qui acceptent un itérable.

Duck typing et typage statique sont-ils compatibles en Python ?

Oui. Python 3.8+ introduit le module typing avec Protocol, qui permet de définir des protocoles structurels utilisables avec les outils de vérification de type statique comme mypy. Un Protocol définit les méthodes attendues sans imposer d'héritage. Cela combine le duck typing à l'exécution avec la vérification statique à la rédaction du code, sans contraindre les classes à hériter d'une classe abstraite.

Le duck typing en Python : programmation flexible sans héritage

OUJOOD.COM

Le duck typing tire son nom d'un principe simple : « Si ça marche comme un canard et que ça cancane comme un canard, alors c'est un canard. » En Python, cela signifie que vous n'avez pas besoin de vérifier le type d'un objet pour l'utiliser — il suffit qu'il possède les méthodes ou attributs dont vous avez besoin.

C'est une différence fondamentale avec des langages comme Java où une fonction qui attend un objet de type Animal refuse tout ce qui n'en hérite pas. En Python, si l'objet sait faire ce qu'on lui demande, il passe. Ce cours explique ce que ça change concrètement et comment en tirer parti.

Un exemple immédiat

La fonction len() fonctionne sur une chaîne, une liste, un tuple, un dictionnaire — sans que ces types n'aient de lien d'héritage entre eux. Python ne vérifie pas le type : il vérifie simplement que l'objet possède une méthode __len__.

📋 Copier le code

# len() fonctionne sur tout objet qui a __len__
print(len("bonjour"))       # str → 7
print(len([1, 2, 3]))       # list → 3
print(len({"a": 1, "b": 2}))# dict → 2
print(len((10, 20)))        # tuple → 2

# Votre propre classe fonctionne aussi si elle a __len__
class Panier:
    def __init__(self, articles):
        self.articles = articles

    def __len__(self):
        return len(self.articles)

panier = Panier(["pain", "lait", "café"])
print(len(panier))
# Résultat : 3

Duck typing vs vérification de type

Voici la différence concrète entre une approche qui vérifie le type et une approche duck typing :

📋 Copier le code

# ❌ Approche rigide : vérification de type
def faire_parler_rigide(animal):
    if isinstance(animal, Chien) or isinstance(animal, Chat):
        animal.parler()
    else:
        print("Je ne connais pas cet animal.")

# ✅ Approche duck typing : on essaie, on attrape si ça échoue
def faire_parler(animal):
    try:
        animal.parler()
    except AttributeError:
        print(f"{type(animal).__name__} ne sait pas parler.")

class Chien:
    def parler(self):
        print("Woof !")

class Chat:
    def parler(self):
        print("Miaou !")

class Robot:
    def parler(self):
        print("Bip boop.")

class Pierre:
    pass

# Fonctionne avec tout objet qui a une méthode parler()
for objet in [Chien(), Chat(), Robot(), Pierre()]:
    faire_parler(objet)
# Résultat :
# Woof !
# Miaou !
# Bip boop.
# Pierre ne sait pas parler.

Exemple pratique : sauvegarder des données

Une fonction qui écrit des données dans un fichier peut accepter n'importe quel objet qui se comporte comme un fichier — un vrai fichier ouvert, un StringIO en mémoire, ou votre propre classe — du moment qu'il a une méthode write().

📋 Copier le code

import io

def sauvegarder(destination, contenu):
    # On ne vérifie pas le type — on demande juste write()
    destination.write(contenu)

# Avec un vrai fichier
with open("sortie.txt", "w", encoding="utf-8") as f:
    sauvegarder(f, "Bonjour depuis un fichier.")

# Avec un StringIO (fichier en mémoire — pratique pour les tests)
buffer = io.StringIO()
sauvegarder(buffer, "Bonjour depuis la mémoire.")
print(buffer.getvalue())
# Résultat : Bonjour depuis la mémoire.

# Avec votre propre classe qui a write()
class Journal:
    def __init__(self):
        self.lignes = []

    def write(self, texte):
        self.lignes.append(texte)
        print(f"[Journal] {texte}")

journal = Journal()
sauvegarder(journal, "Entrée du jour.")
# Résultat : [Journal] Entrée du jour.

Duck typing et les protocoles Python

Python formalise certains comportements duck typing sous forme de protocoles : un ensemble de méthodes spéciales à implémenter pour qu'un objet soit compatible avec une fonctionnalité. Implémenter __iter__ et __next__ rend un objet itérable. Implémenter __enter__ et __exit__ le rend utilisable avec with.

📋 Copier le code

# Rendre une classe itérable (protocole itérateur)
class Compte_a_rebours:
    def __init__(self, debut):
        self.debut = debut
        self.actuel = debut

    def __iter__(self):
        return self

    def __next__(self):
        if self.actuel < 0:
            raise StopIteration
        valeur = self.actuel
        self.actuel -= 1
        return valeur

# Fonctionne dans une boucle for comme n'importe quel itérable
for n in Compte_a_rebours(5):
    print(n, end=" ")
# Résultat : 5 4 3 2 1 0

# Fonctionne aussi avec list(), sum(), max()...
print(list(Compte_a_rebours(3)))
# Résultat : [3, 2, 1, 0]

LBYL vs EAFP : deux styles de duck typing

Face à une opération qui peut échouer, Python reconnaît deux approches. LBYL (Look Before You Leap) vérifie d'abord les conditions. EAFP (Easier to Ask Forgiveness than Permission) tente l'opération et attrape l'exception si ça rate. EAFP est le style idiomatique Python.

📋 Copier le code

donnees = {"nom": "Alice", "age": 30}

# Style LBYL : vérifier avant d'agir
if "email" in donnees:
    print(donnees["email"])
else:
    print("Pas d'email.")

# Style EAFP : tenter et gérer l'échec (préféré en Python)
try:
    print(donnees["email"])
except KeyError:
    print("Pas d'email.")

# Encore plus court avec .get()
print(donnees.get("email", "Pas d'email."))
# Résultat : Pas d'email.

Quand vérifier le type malgré tout ?

Le duck typing ne signifie pas qu'on n'utilise jamais isinstance(). Il y a des cas légitimes : valider les paramètres d'une fonction publique, adapter le comportement selon le type reçu, ou générer un message d'erreur clair. La règle est de ne pas rejeter un objet uniquement parce qu'il n'hérite pas du bon type.

📋 Copier le code

def afficher_elements(collection):
    # isinstance() légitime : message d'erreur explicite
    if not hasattr(collection, "__iter__"):
        raise TypeError(
            f"Attendu un itérable, reçu {type(collection).__name__}"
        )
    for element in collection:
        print(element)

afficher_elements([1, 2, 3])
# Résultat : 1  2  3

afficher_elements("abc")
# Résultat : a  b  c

try:
    afficher_elements(42)
except TypeError as e:
    print(e)
# Résultat : Attendu un itérable, reçu int

Par carabde | Mis à jour le 21 avril 2026

Cours précédent

Sommaire

Cours suivant