Maîtriser la surcharge d'opérateurs en Python : guide pratique

Surcharge d'opérateurs Python

Découvrez comment redéfinir le comportement des opérateurs en Python en utilisant des méthodes spéciales comme __add__, __lt__, et plus, améliorant vos conceptions POO.

Surcharge d'opérateurs Python

Les opérateurs intégrés de Python fonctionnent différemment selon les types d'opérandes. L'opérateur +, par exemple, additionne des nombres, concatène des chaînes ou fusionne des listes. Cette flexibilité est réalisée grâce à la surcharge d'opérateurs — une fonctionnalité qui vous permet d'attribuer des significations contextuelles aux opérateurs pour vos propres classes.

Considérez une simple classe Point qui représente une coordonnée dans un plan 2D. Sans méthodes spéciales, tenter d'additionner deux points lèvera une TypeError :

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1+p2)

Sortie

Traceback (most recent call last): File "<string>", line 9, in <module> print(p1+p2) TypeError: unsupported operand type(s) for +: 'Point' and 'Point'

Comme Python n'a pas de connaissance intégrée de comment combiner deux instances Point, il lève une exception. La surcharge d'opérateurs nous permet de définir ce comportement nous-mêmes.

---

Méthodes spéciales Python

Les méthodes entourées de doubles underscores — __init__, __str__, __add__, etc. — sont connues sous le nom de méthodes spéciales ou méthodes « dunder ». Elles sont invoquées implicitement par l'exécution de Python et sont les points d'ancrage pour la surcharge d'opérateurs, les protocoles de conteneurs, et plus.

Par exemple, la méthode __str__ contrôle comment un objet est converti en chaîne lisible par l'humain. Par défaut, afficher un objet montre son adresse mémoire, ce qui n'est souvent pas utile. Redéfinir __str__ peut rendre le débogage et la journalisation bien plus clairs :

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)

Maintenant, quand nous affichons un Point, nous obtenons :

p1 = Point(2, 3)
print(p1)

Sortie

(2, 3)

La même représentation est utilisée par str(p1) et format(p1) car Python appelle internement p1.__str__().

---

Surcharge de l'opérateur +

Pour personnaliser l'addition pour les objets Point, implémentez __add__ :

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

Test du nouveau comportement :

p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1 + p2)

Sortie

(3, 5)

Sous le capot, Python exécute p1.__add__(p2), qui retourne un nouveau Point avec les coordonnées additionnées.

Voici une référence rapide pour les autres opérateurs arithmétiques et les méthodes spéciales à implémenter :

Opérateur	Expression	Méthode spéciale
Addition	p1 + p2	__add__(self, other)
Soustraction	p1 - p2	__sub__(self, other)
Multiplication	p1 * p2	__mul__(self, other)
Puissance	p1 ** p2	__pow__(self, other)
Division	p1 / p2	__truediv__(self, other)
Division entière	p1 // p2	__floordiv__(self, other)
Modulo	p1 % p2	__mod__(self, other)
Décalage gauche	p1 << p2	__lshift__(self, other)
Décalage droit	p1 >> p2	__rshift__(self, other)
ET bit à bit	p1 & p2	__and__(self, other)
OU bit à bit	p1 | p2	__or__(self, other)
OU exclusif bit à bit	p1 ^ p2	__xor__(self, other)
NON bit à bit	~p1	__invert__(self)

---

Surcharge des opérateurs de comparaison

La surcharge d'opérateurs n'est pas limitée à l'arithmétique. Les opérateurs de comparaison peuvent aussi être adaptés. Par exemple, pour comparer des points basés sur leur distance à l'origine, redéfinissez __lt__ :

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)
    def __lt__(self, other):
        self_mag = self.x**2 + self.y**2
        other_mag = other.x**2 + other.y**2
        return self_mag < other_mag

Utilisation :

p1 = Point(1, 1)
p2 = Point(-2, -3)
p3 = Point(1, -1)
print(p1 < p2)  # True
print(p2 < p3)  # False
print(p1 < p3)  # False

Les autres méthodes de comparaison suivent un motif similaire :

Opérateur	Expression	Méthode spéciale
Inférieur à	p1 < p2	__lt__(self, other)
Inférieur ou égal à	p1 <= p2	__le__(self, other)
Égal à	p1 == p2	__eq__(self, other)
Différent de	p1 != p2	__ne__(self, other)
Supérieur à	p1 > p2	__gt__(self, other)
Supérieur ou égal à	p1 >= p2	__ge__(self, other)

En définissant soigneusement ces méthodes, vous pouvez faire participer des objets personnalisés naturellement dans des contextes arithmétiques et de comparaison, améliorant ainsi la lisibilité et la maintenabilité du code.