Python Language Surcharge de l'opérateur


Exemple

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.

NB L'utilisation d'un other nom de variable n'est pas obligatoire, mais est considérée comme la norme.

Opérateur Méthode Expression
+ Ajout __add__(self, other) a1 + a2
- soustraction __sub__(self, other) a1 - a2
* Multiplication __mul__(self, other) a1 * a2
@ Multiplication de matrices __matmul__(self, other) a1 @ a2 ( Python 3.5 )
/ Division __div__(self, other) a1 / a2 ( Python 2 uniquement )
/ Division __truediv__(self, other) a1 / a2 ( Python 3 )
// Division de plancher __floordiv__(self, other) a1 // a2
% Modulo / reste __mod__(self, other) a1 % a2
** puissance __pow__(self, other[, modulo]) a1 ** a2
<< Changement bit à gauche __lshift__(self, other) a1 << a2
>> Changement de bit à droite __rshift__(self, other) a1 >> a2
& Bitwise ET __and__(self, other) a1 & a2
^ Bit-bit XOR __xor__(self, other) a1 ^ a2
| (Bit à bit OU) __or__(self, other) a1 | a2
- Négation (arithmétique) __neg__(self) -a1
+ Positif __pos__(self) +a1
~ Pas binaire __invert__(self) ~a1
< Moins que __lt__(self, other) a1 < a2
<= Inférieur ou égal à __le__(self, other) a1 <= a2
== égal à __eq__(self, other) a1 == a2
!= Pas égal à __ne__(self, other) a1 != a2
> Supérieur à __gt__(self, other) a1 > a2
>= Supérieur ou égal à __ge__(self, other) a1 >= a2
[index] Opérateur d'index __getitem__(self, index) a1[index]
in opérateur In __contains__(self, other) 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, other):
        return self.a + other
    def __radd__(self, other):
        print("radd")
        return other + 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, other):
        self.b += other
        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, et bien plus encore.