Les Méthodes Magiques

En Python, les méthodes magiques sont des méthodes spéciales que vous pouvez définir pour enrichir vos classes. Elles sont également appelées méthodes "dunder", en raison des doubles tirets bas __ qui encadrent leurs noms. Vous avez déjà rencontré deux de ces méthodes : __init__ et __str__. Regardez un exemple simple :

class Circle:
    def __init__(self, radius):                     # Initialiser l'objet
        self.radius = radius

    def __str__(self):                              # Représenter sous forme de chaîne
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Créer un objet Circle nommé c
print(c)         # Circle with radius 5

Dans cet exemple, nous avons défini deux méthodes magiques :

__init__ est une méthode de construction qui est appelée lors de la création d'une instance de la classe. Ici, elle initialise le rayon du cercle.

__str__ définit comment une instance de la classe doit être convertie en une chaîne de caractères lorsqu'elle est utilisée dans des contextes comme print().

Mais ce ne sont pas les seules méthodes magiques en Python. Il y en a beaucoup d'autres. Certaines sont présentées ci-dessous et nous permettent de faire en sorte que les instances de classe puissent être additionnées avec un + ou comparées avec < ou > :

class Circle:
    def __init__(self, radius):                     # Initialiser l'objet
        self.radius = radius

    def __str__(self):                              # Représenter sous forme de chaîne
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Additionner deux cercles
        return Circle(self.radius + other.radius)   # Retourner un nouveau cercle

    def __lt__(self, other):                        # Comparaison "moins que" de deux cercles
        return self.radius < other.radius           # Comparer les rayons

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # Cela créerait un nouveau Circle avec un rayon de 12
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

Dans ce cas :

__add__ nous permet d'utiliser l'opérateur + avec des instances de Circle. Il additionne les rayons des cercles et retourne un nouveau cercle.

__lt__ ("less than") nous permet de comparer deux instances de Circle avec l'opérateur <. Il vérifie si le rayon du premier cercle est inférieur à celui du second.

Les méthodes magiques rendent nos classes Python plus expressives et intuitives, les faisant se comporter davantage comme les objets intégrés de Python.

N'oubliez pas de conserver la nomenclature spéciale avec les doubles tirets bas, car l'interpréteur Python recherche ces méthodes spécialement nommées pour effectuer certaines opérations. Vous pouvez trouver la liste de toutes les méthodes magiques disponibles en Python en suivant ce lien. Voici quelques-unes des méthodes magiques les plus populaires :

Méthode Magique	Opérateur	Description
`__eq__`	`==`	Retourne `True` si `self` est égal à `other`.
`__lt__`	`<`	Retourne `True` si `self` est inférieur à `other`.
`__le__`	`<=`	Retourne `True` si `self` est inférieur ou égal à `other`.
`__gt__`	`>`	Retourne `True` si `self` est supérieur à `other`.
`__ge__`	`>=`	Retourne `True` si `self` est supérieur ou égal à `other`.
`__add__(self, other)`	`+`	Implémente l'addition avec l'opérateur `+`.
`__sub__(self, other)`	`-`	Implémente la soustraction avec l'opérateur `-`.
`__mul__(self, other)`	`*`	Implémente la multiplication avec l'opérateur `*`.
`__truediv__(self, other)`	`/`	Implémente la division avec l'opérateur `/`.
`__floordiv__(self, other)`	`//`	Implémente la division entière avec l'opérateur `//`.
`__mod__(self, other)`	`%`	Implémente le modulo avec l'opérateur `%`.
`__pow__(self, other)`	`**`	Implémente l'opérateur puissance `**`.
`__abs__(self)`	`abs()`	Implémente le comportement de la fonction intégrée `abs()`.
`__round__(self, n)`	`round()`	Implémente le comportement de la fonction intégrée `round()`.
`__neg__(self)`	`-`	Implémente la négation avec l'opérateur unaire `-`.

💡

Notez que toutes les méthodes ne sont pas utiles pour toutes les classes ; vous devriez n'implémenter que celles qui sont pertinentes pour votre problème.

Défi : Créer une classe Vector

Vous devez définir une classe Vector qui représente un vecteur tridimensionnel avec les attributs x, y et z.

La classe doit inclure l'implémentation des méthodes spéciales __add__, __sub__ et __mul__ pour l'addition, la soustraction et le produit scalaire de vecteurs, respectivement.

En plus de cela, implémentez une méthode magnitude pour calculer la norme (longueur) du vecteur.

Les méthodes demandées :

__add__ : Cette méthode doit accepter un autre objet Vector et retourner un nouveau vecteur qui est le résultat de l'addition des composantes x, y et z des deux vecteurs.

__sub__ : Cette méthode doit accepter un autre objet Vector et retourner un nouveau vecteur qui est le résultat de la soustraction des composantes x, y et z du second vecteur au premier.

__mul__ : Cette méthode doit accepter un autre objet Vector et retourner le produit scalaire des deux vecteurs, calculé comme $$(x1 \cdot x2) + (y1 \cdot y2) + (z1 \cdot z2)$$.

magnitude : Cette méthode doit retourner la norme (longueur) du vecteur, calculée comme $$\sqrt{x^2 + y^2 + z^2}$$.

Entrée	Sortie
`v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)`	32 3.74165

Défi : Créer une classe Vector

Constraints

To check your solution you need to sign in

Sign in to continue