Surcharge des opérateurs

La surcharge d’opérateurs vous permet d’utiliser des opérateurs standards tels que
+, -, * etc sur les classes.

La surcharge d’opérateurs vous permet de redéfinir la signification d’opérateur en

fonction de votre classe. Cette fonctionnalité en Python, qui permet à un même
opérateur d’avoir une signification différente en fonction du contexte, est appelée
surcharge d’opérateur. Alors que se passe-t-il lorsque nous les utilisons avec des objets
d'une classe définie par l'utilisateur ? Considérons la classe suivante :

Exemple :

1 class Point:
2 def __init__(self, x, y):
3 self.x = x
4 self.y = y
5
6
7 p1 = Point(2, 4)
8 p2 = Point(5, 1)
9
10 p3 = p1+p2
Traceback (most recent call last):
File "prog.py", line 10, in < module>
p3 = p1+p2
TypeError: unsupported operand type(s) for +: 'Point' and 'Point'
TypeError a été généré car Python ne savait pas comment ajouter deux objets Point
ensemble.
La surcharge de l'opérateur est obtenue en définissant une méthode spéciale dans la
définition de classe. Les noms de ces méthodes commencent et finissent par un double
soulignement (__).

Opérateurs arithmétiques

Opérateur +

Pour surcharger l'opérateur +, nous devrons implémenter la fonction __add __ () dans

la classe. Nous pouvons faire ce que nous voulons, dans cette fonction.
Exemple :

1 class Point:
2 def __init__(self, x, y):
3 self.x = x
4 self.y = y
5
6 def __str__(self):
7 return "({0},{1})".format(self.x, self.y)
8
9 def __add__(self, p):
10 a = self.x + p.x
11 b = self.y + p.y
12 return Point(a, b)
13
14
15 p1 = Point(2, 4)
16 p2 = Point(5, 1)
17
18 p3 = p1+p2
19 print(p3)
(7,5)
Si l'expression est de la forme x + y, Python l'interprète comme x .__ add __ (y). La
version de la méthode __add __ () appelée dépend du type de x et de y.

Vous trouverez ci-dessous les opérateurs pouvant être surchargés dans les classes,
ainsi que les définitions de méthode requises et un exemple de l'opérateur utilisé dans
une expression.

L'utilisation d'un autre nom de variable n'est pas obligatoire, mais est considérée
comme la norme.
Opérateur Méthode Expression
+ Ajout __add__(self, autre) a1 + a2
- soustraction __sub__(self, autre) a1 - a2
* Multiplication __mul__(self, autre) a1 * a2
@ Multiplication de matrices __matmul__(self, autre) a1 @ a2 ( Python 3.5 )
/ Division __div__(self, autre) a1 / a2 ( Python 2
uniquement )
/ Division __truediv__(self, autre) a1 / a2 ( Python 3 )
// Division de plancher __floordiv__(self, autre) a1 // a2
% Modulo / reste __mod__(self, autre) a1 % a2
** puissance __pow__(self, autre[, modulo]) a1 ** a2
<< Changement bit à gauche __lshift__(self, autre) a1 << a2
>> Changement de bit à droite __rshift__(self, autre) a1 >> a2
& Bitwise ET __and__(self, autre) a1 & a2
^ Bit-bit XOR __xor__(self, autre) a1 ^ a2
| (Bit à bit OU) __or__(self, autre) a1 | a2
- Négation (arithmétique) __neg__(self) -a1
+ Positif __pos__(self) +a1
~ Pas binaire __invert__(self) ~a1
< Moins que __lt__(self, autre) a1 < a2
<= Inférieur ou égal à __le__(self, autre) a1 <= a2
== égal à __eq__(self, autre) a1 == a2
!= Pas égal à __ne__(self, autre) a1 != a2
> Supérieur à __gt__(self, autre) a1 > a2
>= Supérieur ou égal à __ge__(self, autre) a1 >= a2
[index] Opérateur d'index __getitem__(self, index) a1[index]
in opérateur In __contains__(self, autre) a2 in a1
(*args, ...) Appel __call__(self, *args, **kwargs) a1(*args, **kwargs)

Le paramètre optionnel modulo pour __pow__ n'est utilisé que par la fonction
intégrée pow .

Chacune des méthodes correspondant à un opérateur binaire a une méthode "droite"

correspondante qui commence par __r , par exemple __radd__ :

class A:
def __init__(self, a):
self.a = a
def __add__(self, autre):
return self.a + autre
def __radd__(self, autre):
print("radd")
return autre + self.a

A(1) + 2 # Out: 3
2 + A(1) # prints radd. Out: 3
ainsi qu'une version correspondante en place, commençant par __i :

class B:
def __init__(self, b):
self.b = b
def __iadd__(self, autre):
self.b += autre
print("iadd")
return self

b = B(2)
b.b # Out: 2
b += 1 # prints iadd
b.b # Out: 3

Comme ces méthodes n'ont rien de particulier, de nombreuses autres parties du

langage, des parties de la bibliothèque standard et même des modules tiers ajoutent
des méthodes magiques, comme des méthodes pour convertir un objet en type ou
vérifier les propriétés de l'objet.

Par exemple, la fonction intégrée str() appelle la méthode __str__ l'objet, si elle
existe. Certaines de ces utilisations sont énumérées ci-dessous.

Fonction Méthode Expression

Casting à l' int __int__(self) int(a1)
Fonction absolue __abs__(self) abs(a1)
Casting à str __str__(self) str(a1)
Casting à unicode __unicode__(self) unicode(a1) (Python 2
uniquement)
Représentation de chaîne __repr__(self) repr(a1)
Casting à bool __nonzero__(self) bool(a1)
Formatage de chaîne __format__(self, formatstr) "Hi {:abc}".format(a1)
Hachage __hash__(self) hash(a1)
Longueur __len__(self) len(a1)
Renversé __reversed__(self) reversed(a1)
Sol __floor__(self) math.floor(a1)
Plafond __ceil__(self) math.ceil(a1)

Il existe également les méthodes spéciales __enter__ et __exit__ pour les

gestionnaires de contexte.