Qu'est-ce que les méthodes spéciales (dunder methods) en Python ?

Les méthodes spéciales, aussi appelées dunder methods (de double underscore), sont des méthodes encadrées de doubles underscores comme __init__, __str__ ou __len__. Python les appelle automatiquement en réponse à certaines opérations : __len__ est appelée par len(), __add__ par l'opérateur +, __str__ par print(). Elles permettent à vos classes de s'intégrer naturellement dans la syntaxe Python.

Quelle est la différence entre __str__ et __repr__ en Python ?

__str__ définit la représentation lisible d'un objet, affichée par print() et str(). Elle est destinée aux utilisateurs. __repr__ définit la représentation technique, affichée dans le shell interactif et par repr(). Elle est destinée aux développeurs et doit idéalement permettre de recréer l'objet. Si __str__ n'est pas défini, Python utilise __repr__ à sa place.

Comment rendre une classe Python comparable avec == ?

Définissez la méthode __eq__(self, autre) dans votre classe. Sans elle, Python compare l'identité des objets (leur adresse mémoire), pas leur contenu — deux objets distincts mais identiques seraient considérés différents. Dans __eq__, retournez True ou False selon les attributs à comparer. Exemple : return self.nom == autre.nom and self.prix == autre.prix.

Comment rendre des objets Python triables avec sorted() ?

Définissez __lt__(self, autre) qui retourne True si self est inférieur à autre. sorted() et list.sort() utilisent cette méthode pour comparer les objets. Pour définir toutes les comparaisons ( , >=, ==) sans tout écrire à la main, utilisez le décorateur @functools.total_ordering avec __eq__ et __lt__ : Python déduira les autres comparaisons automatiquement.

Comment surcharger l'opérateur + pour une classe Python ?

Définissez la méthode __add__(self, autre) qui retourne un nouvel objet représentant le résultat de l'addition. Python appelle cette méthode quand il rencontre obj1 + obj2. De même, __sub__ gère -, __mul__ gère *, __truediv__ gère /. La méthode doit retourner un nouvel objet sans modifier les opérandes originaux.

À quoi sert __getitem__ en Python ?

__getitem__(self, clé) est appelée quand on écrit objet[clé]. Elle permet à vos objets d'être accessibles comme des listes ou des dictionnaires. Combinée avec __setitem__(self, clé, valeur) pour l'assignation objet[clé] = valeur, et __delitem__(self, clé) pour del objet[clé], elle donne à vos classes une interface de conteneur complète.

Peut-on appeler directement les méthodes spéciales Python ?

Techniquement oui — objet.__len__() est valide. Mais ce n'est pas recommandé. La convention Python est d'utiliser les fonctions et opérateurs intégrés : len(objet), str(objet), objet + autre. Ces appels indirects passent par le protocole Python et gèrent correctement les cas particuliers. L'appel direct des dunder methods contourne ce mécanisme.

Les méthodes spéciales Python : __init__, __str__, __len_

OUJOOD.COM

Quand vous écrivez len(ma_liste), Python appelle en réalité ma_liste.__len__(). Quand vous faites a + b, Python appelle a.__add__(b). Ces méthodes encadrées de doubles underscores — qu'on appelle dunder methods (de double underscore) ou méthodes spéciales — sont le mécanisme qui permet à vos propres classes de s'intégrer naturellement dans la syntaxe Python.

Définir __len__ dans votre classe, c'est rendre len() utilisable dessus. Définir __add__, c'est permettre l'opérateur +. Ce cours présente les méthodes spéciales les plus utiles avec des exemples concrets.

init : le constructeur

__init__ est appelée automatiquement à la création d'un objet. C'est ici qu'on initialise les attributs de l'instance. Elle ne retourne rien — son rôle est uniquement de préparer l'objet.

📋 Copier le code

class Livre:
    def __init__(self, titre, auteur, pages):
        self.titre = titre
        self.auteur = auteur
        self.pages = pages

livre = Livre("Le Petit Prince", "Saint-Exupéry", 96)
print(livre.titre)
# Résultat : Le Petit Prince

str et repr : représentation textuelle

__str__ définit ce qu'affiche print(objet) — une représentation lisible pour un humain. __repr__ définit la représentation technique, affichée dans le shell interactif ou avec repr(objet). Si __str__ n'est pas défini, Python utilise __repr__ à la place.

📋 Copier le code

class Livre:
    def __init__(self, titre, auteur, pages):
        self.titre = titre
        self.auteur = auteur
        self.pages = pages

    def __str__(self):
        # Lisible pour l'utilisateur
        return f"{self.titre} de {self.auteur} ({self.pages} pages)"

    def __repr__(self):
        # Représentation technique pour les développeurs
        return f"Livre(titre={self.titre!r}, auteur={self.auteur!r}, pages={self.pages})"

livre = Livre("1984", "Orwell", 328)

print(str(livre))
# Résultat : 1984 de Orwell (328 pages)

print(repr(livre))
# Résultat : Livre(titre='1984', auteur='Orwell', pages=328)

len : rendre len() utilisable

__len__ permet d'appeler len() sur vos objets. Elle doit retourner un entier positif ou nul.

📋 Copier le code

class Bibliotheque:
    def __init__(self):
        self.livres = []

    def ajouter(self, livre):
        self.livres.append(livre)

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

biblio = Bibliotheque()
biblio.ajouter("1984")
biblio.ajouter("Le Petit Prince")
biblio.ajouter("Dune")

print(len(biblio))
# Résultat : 3

eq et lt : comparaisons

__eq__ définit le comportement de l'opérateur ==. Sans lui, Python compare l'identité des objets (leur adresse mémoire), pas leur contenu. __lt__ définit <, et une fois défini, sorted() peut trier vos objets.

📋 Copier le code

class Produit:
    def __init__(self, nom, prix):
        self.nom = nom
        self.prix = prix

    def __eq__(self, autre):
        # Deux produits sont égaux si même nom et même prix
        return self.nom == autre.nom and self.prix == autre.prix

    def __lt__(self, autre):
        # Comparer par prix pour le tri
        return self.prix < autre.prix

    def __str__(self):
        return f"{self.nom} ({self.prix}€)"

p1 = Produit("Clavier", 49)
p2 = Produit("Souris", 29)
p3 = Produit("Clavier", 49)

print(p1 == p3)
# Résultat : True (même nom et même prix)

print(p1 == p2)
# Résultat : False

produits = [p1, p2, Produit("Écran", 199)]
for p in sorted(produits):
    print(p)
# Résultat (triés par prix) :
# Souris (29€)
# Clavier (49€)
# Écran (199€)

add et mul : opérateurs arithmétiques

Ces méthodes permettent d'utiliser les opérateurs +, -, * avec vos objets. Python appelle __add__ quand il rencontre a + b.

📋 Copier le code

class Vecteur:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, autre):
        return Vecteur(self.x + autre.x, self.y + autre.y)

    def __mul__(self, scalaire):
        return Vecteur(self.x * scalaire, self.y * scalaire)

    def __str__(self):
        return f"Vecteur({self.x}, {self.y})"

v1 = Vecteur(1, 2)
v2 = Vecteur(3, 4)

print(v1 + v2)
# Résultat : Vecteur(4, 6)

print(v1 * 3)
# Résultat : Vecteur(3, 6)

getitem et setitem : accès par index

__getitem__ permet d'utiliser la notation objet[index]. __setitem__ permet objet[index] = valeur. C'est ce qui rend vos objets accessibles comme des listes ou des dictionnaires.

📋 Copier le code

class Panier:
    def __init__(self):
        self._articles = {}

    def __setitem__(self, article, quantite):
        self._articles[article] = quantite

    def __getitem__(self, article):
        return self._articles.get(article, 0)

    def __str__(self):
        return str(self._articles)

panier = Panier()
panier["pommes"] = 3
panier["poires"] = 2

print(panier["pommes"])
# Résultat : 3

print(panier["cerises"])
# Résultat : 0 (absent, valeur par défaut)

contains : l'opérateur in

__contains__ définit le comportement de l'opérateur in. Sans lui, Python parcourt l'objet avec __iter__ si disponible.

📋 Copier le code

class ListeNoire:
    def __init__(self):
        self._interdits = set()

    def ajouter(self, element):
        self._interdits.add(element)

    def __contains__(self, element):
        return element in self._interdits

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

liste = ListeNoire()
liste.ajouter("spam@exemple.com")
liste.ajouter("bot@fake.net")

print("spam@exemple.com" in liste)
# Résultat : True

print("alice@exemple.com" in liste)
# Résultat : False

Récapitulatif des méthodes spéciales essentielles

Méthode	Déclenchée par	Usage typique
__init__	`Classe()`	Initialiser les attributs
__str__	`print(obj)`, `str(obj)`	Affichage lisible
__repr__	`repr(obj)`, shell	Représentation technique
__len__	`len(obj)`	Taille d'un conteneur
__eq__	`obj1 == obj2`	Égalité par contenu
__lt__	`obj1 < obj2`, `sorted()`	Tri des objets
__add__	`obj1 + obj2`	Opérateur addition
__mul__	`obj * n`	Opérateur multiplication
__getitem__	`obj[clé]`	Accès par index/clé
__setitem__	`obj[clé] = val`	Assignation par index/clé
__contains__	`val in obj`	Test d'appartenance