Méthodes magiques en Python
Cet article explique les méthodes magiques en Python.
YouTube Video
Méthodes magiques en Python
Les méthodes magiques (méthodes spéciales) en Python sont des méthodes nommées de manière spéciale, utilisées pour donner aux classes des comportements uniques. Par exemple, elles se caractérisent par le fait d'être entourées de doubles underscores (dunders), comme __init__ et __str__. C'est pourquoi elles sont également appelées méthodes dunder.
En définissant des méthodes magiques, vous pouvez personnaliser le comportement standard des classes. Par exemple, définir __add__ permet de modifier le comportement de l’opérateur +.
Méthodes magiques pour l'initialisation et la représentation en chaîne de caractères
__init__ : Méthode d'initialisation
La méthode __init__ est un constructeur appelé automatiquement lors de la création d'une instance.
1class Person:
2 def __init__(self, name, age):
3 self.name = name
4 self.age = age
5
6person = Person("Alice", 30)
7print(person.name) # Alice__str__ : Représentation sous forme de chaîne lisible par l’homme
La méthode __str__ renvoie une représentation en chaîne lisible par l’homme. Elle est appelée par print() et str().
1class Person:
2 def __init__(self, name):
3 self.name = name
4
5 def __str__(self):
6 return f"Person: {self.name}"
7
8person = Person("Bob")
9print(person) # Person: Bob__repr__ : Représentation de chaîne destinée au débogage
La méthode __repr__ renvoie une représentation en chaîne destinée au débogage. Elle est utilisée par repr() et lors de l’affichage dans l’interpréteur.
1class Person:
2 def __init__(self, name):
3 self.name = name
4
5 def __repr__(self):
6 return f"Person(name={self.name!r})"
7
8person = Person("Eve")
9print(repr(person)) # Person(name='Eve')Surcharge des opérateurs arithmétiques
__add__ : opérateur +
En utilisant des méthodes magiques, les opérateurs arithmétiques peuvent être surchargés. Par exemple, la méthode __add__ permet de surcharger l’opérateur +.
1class Vector:
2 def __init__(self, x, y):
3 self.x = x
4 self.y = y
5
6 def __add__(self, other):
7 return Vector(self.x + other.x, self.y + other.y)
8
9 def __repr__(self):
10 return f"Vector({self.x}, {self.y})"
11
12 # Other arithmetic magic methods:
13 # def __sub__(self, other): # Subtraction (-)
14 # def __mul__(self, other): # Multiplication (*)
15 # def __truediv__(self, other): # True division (/)
16 # def __floordiv__(self, other): # Floor division (//)
17 # def __mod__(self, other): # Modulo (%)
18 # def __pow__(self, other): # Exponentiation (**)
19
20v1 = Vector(1, 2)
21v2 = Vector(3, 4)
22print(v1 + v2) # Vector(4, 6)Parmi les autres méthodes magiques arithmétiques, on trouve :.
| Méthode | Opérateur |
|---|---|
__add__ |
+ |
__sub__ |
- |
__mul__ |
* |
__truediv__ |
/ |
__floordiv__ |
// |
__mod__ |
% |
__pow__ |
** |
Personnalisation des opérateurs de comparaison
Vous pouvez également surcharger les opérateurs de comparaison. Par exemple, la méthode __eq__ surcharge l’opérateur d’égalité.
1class Box:
2 def __init__(self, volume):
3 self.volume = volume
4
5 def __eq__(self, other):
6 return self.volume == other.volume
7
8 def __lt__(self, other):
9 return self.volume < other.volume
10
11 # Comparison magic methods:
12 # def __eq__(self, other): # Equal to (==)
13 # def __ne__(self, other): # Not equal to (!=)
14 # def __lt__(self, other): # Less than (<)
15 # def __le__(self, other): # Less than or equal to (<=)
16 # def __gt__(self, other): # Greater than (>)
17 # def __ge__(self, other): # Greater than or equal to (>=)
18
19b1 = Box(100)
20b2 = Box(200)
21
22print(b1 == b2) # False
23print(b1 < b2) # TrueIl existe également les méthodes magiques suivantes :. Ces méthodes magiques définissent des comparaisons telles que l’égalité et l’ordre entre les objets.
| Opérateur | Méthode magique |
|---|---|
== |
__eq__ |
!= |
__ne__ |
< |
__lt__ |
<= |
__le__ |
> |
__gt__ |
>= |
__ge__ |
Méthodes magiques pour les types de conteneurs
Vous pouvez créer des classes qui se comportent comme des listes ou des dictionnaires.
__len__ : Obtenir le nombre d’éléments
La méthode __len__ est une méthode magique qui renvoie le nombre d’éléments.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __len__(self):
6 return len(self.items)
7
8basket = Basket(["apple", "banana"])
9print(len(basket)) # 2__getitem__ : Accès par index
La méthode __getitem__ est appelée lors de l’accès par index.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __getitem__(self, index):
6 return self.items[index]
7
8basket = Basket(["apple", "banana"])
9print(basket[1]) # banana__setitem__ et __delitem__ : écriture et suppression
Les méthodes __setitem__ et __delitem__ sont appelées lors de l’écriture ou de la suppression d’éléments.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __setitem__(self, index, value):
6 self.items[index] = value
7
8 def __delitem__(self, index):
9 del self.items[index]
10
11basket = Basket(["apple", "banana"])
12basket[1] = "grape"
13del basket[0]
14print(basket.items) # ['grape']Méthodes magiques pour l’itération
Pour rendre un objet itérable dans une boucle for, implémentez ce qui suit :.
__iter__ et __next__
1class Counter:
2 def __init__(self, limit):
3 self.limit = limit
4 self.current = 0
5
6 def __iter__(self):
7 return self
8
9 def __next__(self):
10 if self.current >= self.limit:
11 raise StopIteration
12 self.current += 1
13 return self.current
14
15for num in Counter(3):
16 print(num)
17# Output:
18# 1
19# 2
20# 3Gestionnaire de contexte (with)
En définissant les méthodes __enter__ et __exit__, vous pouvez implémenter les traitements avant et après pour l’instruction with.
1class FileOpener:
2 def __init__(self, filename):
3 self.filename = filename
4
5 def __enter__(self):
6 self.file = open(self.filename, 'r')
7 return self.file
8
9 def __exit__(self, exc_type, exc_val, exc_tb):
10 self.file.close()
11
12with FileOpener("example.txt") as f:
13 content = f.read()
14 print(content)Objets appelables : __call__
En définissant la méthode __call__, vous pouvez rendre une instance appelable comme une fonction.
1class Greeter:
2 def __init__(self, greeting):
3 self.greeting = greeting
4
5 def __call__(self, name):
6 return f"{self.greeting}, {name}!"
7
8hello = Greeter("Hello")
9print(hello("Alice")) # Hello, Alice!Résumé
Les méthodes magiques en Python sont un moyen puissant d’ajouter un comportement naturel et intuitif aux classes. Chaque méthode a un objectif précis, et les implémenter correctement permet d’écrire du code plus flexible et plus pythonique.
Les méthodes magiques servent d’« interface invisible » qui supporte la façon dont les objets Python interagissent et se comportent en arrière-plan.
Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.