Surcharge d'opérateur Python
Surcharge d'opérateur Python
Vous pouvez modifier la signification d'un opérateur en Python en fonction des opérandes utilisés. Dans ce didacticiel, vous apprendrez à utiliser la surcharge d'opérateurs dans la programmation orientée objet Python.
Surcharge d'opérateur Python
Les opérateurs Python fonctionnent pour les classes intégrées. Mais le même opérateur se comporte différemment avec différents types. Par exemple, le + effectuera une addition arithmétique sur deux nombres, fusionnera deux listes ou concatènera deux chaînes.
Cette fonctionnalité de Python qui permet au même opérateur d'avoir une signification différente selon le contexte s'appelle la surcharge d'opérateur.
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, qui tente de simuler un point dans un système de coordonnées 2D.
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'
Ici, nous pouvons voir qu'un TypeError a été soulevé, car Python ne savait pas comment ajouter deux Point objets ensemble.
Cependant, nous pouvons accomplir cette tâche en Python grâce à la surcharge des opérateurs. Mais d'abord, essayons de comprendre les fonctions spéciales.
Fonctions spéciales Python
Fonctions de classe commençant par un double trait de soulignement __ sont appelées fonctions spéciales en Python.
Ces fonctions ne sont pas les fonctions typiques que nous définissons pour une classe. Le __init__() la fonction que nous avons définie ci-dessus en fait partie. Il est appelé chaque fois que nous créons un nouvel objet de cette classe.
Il existe de nombreuses autres fonctions spéciales en Python. Visitez les fonctions spéciales de Python pour en savoir plus à leur sujet.
En utilisant des fonctions spéciales, nous pouvons rendre notre classe compatible avec les fonctions intégrées.
>>> p1 = Point(2,3)
>>> print(p1)
<__main__.Point object at 0x00000000031F8CC0>
Supposons que nous voulions le print() fonction pour imprimer les coordonnées du Point objet au lieu de ce que nous avons obtenu. On peut définir un __str__() méthode dans notre classe qui contrôle la façon dont l'objet est imprimé. Voyons comment nous pouvons y parvenir :
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)
Essayons maintenant le print() fonctionner à nouveau.
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)
p1 = Point(2, 3)
print(p1) Sortie
(2, 3)
C'est mieux. Il s'avère que cette même méthode est invoquée lorsque nous utilisons la fonction intégrée str() ou format() .
>>> str(p1)
'(2,3)'
>>> format(p1)
'(2,3)'
Ainsi, lorsque vous utilisez str(p1) ou format(p1) , Python appelle en interne le p1.__str__() méthode. D'où le nom, fonctions spéciales.
Revenons maintenant à la surcharge des opérateurs.
Surcharger l'opérateur +
Pour surcharger le + opérateur, nous devrons implémenter __add__() fonction dans la classe. Un grand pouvoir implique de grandes responsabilités. Nous pouvons faire ce que nous voulons, à l'intérieur de cette fonction. Mais il est plus judicieux de retourner un Point objet de la somme des coordonnées.
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):
x = self.x + other.x
y = self.y + other.y
return Point(x, y) Essayons à nouveau l'opération d'addition :
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):
x = self.x + other.x
y = self.y + other.y
return Point(x, y)
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1+p2) Sortie
(3,5)
Ce qui se passe réellement, c'est que lorsque vous utilisez p1 + p2 , Python appelle p1.__add__(p2) qui à son tour est Point.__add__(p1,p2) . Après cela, l'opération d'ajout est effectuée comme nous l'avons spécifié.
De même, nous pouvons également surcharger d'autres opérateurs. La fonction spéciale que nous devons implémenter est tabulée ci-dessous.
| Opérateur | Expression | En interne |
|---|---|---|
| Ajout | p1 + p2 | p1.__add__(p2) |
| Soustraction | p1 - p2 | p1.__sub__(p2) |
| Multiplication | p1 * p2 | p1.__mul__(p2) |
| Puissance | p1 ** p2 | p1.__pow__(p2) |
| Division | p1 / p2 | p1.__truediv__(p2) |
| Division d'étage | p1 // p2 | p1.__floordiv__(p2) |
| Reste (modulo) | p1 % p2 | p1.__mod__(p2) |
| Décalage bit à gauche | p1 << p2 | p1.__lshift__(p2) |
| Décalage bit à droite | p1 >> p2 | p1.__rshift__(p2) |
| ET au niveau du bit | p1 & p2 | p1.__and__(p2) |
| OU au niveau du bit | p1 | p2 | p1.__or__(p2) |
| XOR au niveau du bit | p1 ^ p2 | p1.__xor__(p2) |
| NON au niveau du bit | ~p1 | p1.__invert__() |
Surcharger les opérateurs de comparaison
Python ne limite pas la surcharge d'opérateurs aux seuls opérateurs arithmétiques. Nous pouvons également surcharger les opérateurs de comparaison.
Supposons que nous voulions implémenter le symbole inférieur à < symbole dans notre Point classe.
Comparons la magnitude de ces points à partir de l'origine et renvoyons le résultat à cet effet. Il peut être implémenté comme suit.
# overloading the less than operator
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
p1 = Point(1,1)
p2 = Point(-2,-3)
p3 = Point(1,-1)
# use less than
print(p1<p2)
print(p2<p3)
print(p1<p3) Sortie
True False False
De même, les fonctions spéciales que nous devons implémenter pour surcharger d'autres opérateurs de comparaison sont répertoriées ci-dessous.
| Opérateur | Expression | En interne |
|---|---|---|
| Moins de | p1 < p2 | p1.__lt__(p2) |
| Inférieur ou égal à | p1 <= p2 | p1.__le__(p2) |
| Égal à | p1 == p2 | p1.__eq__(p2) |
| Pas égal à | p1 != p2 | p1.__ne__(p2) |
| Supérieur à | p1 > p2 | p1.__gt__(p2) |
| Supérieur ou égal à | p1 >= p2 | p1.__ge__(p2) |
Python