Que sont les méthodes magiques en Python et comment les utiliser

L’une des fonctionnalités les moins connues mais précieuses de Python est la possibilité d’implémenter des méthodes magiques sur des objets. En utilisant des méthodes magiques, nous pouvons écrire un code plus propre, intuitif et facile à comprendre.

Avec des méthodes magiques, nous pouvons créer des interfaces pour interagir avec des objets d’une manière qui semble plus pythonique. Cet article vous présentera les méthodes magiques, discutera des meilleures pratiques pour les créer et explorera les méthodes magiques courantes que vous rencontrerez.

Que sont les méthodes magiques ?

Les méthodes magiques sont des méthodes Python qui définissent le comportement des objets Python lorsque des opérations courantes sont effectuées sur eux. Ces méthodes sont clairement définies avec des traits de soulignement doubles avant et après le nom de la méthode.

En conséquence, elles sont communément appelées méthodes dunder, comme dans le double trait de soulignement. Une méthode dunder courante que vous avez peut-être déjà rencontrée est la méthode __init__() qui est utilisée pour définir les constructeurs de classe.

En règle générale, les méthodes dunder ne sont pas destinées à être appelées directement dans votre code ; ils seront plutôt appelés par l’interpréteur pendant l’exécution du programme.

Pourquoi les méthodes magiques sont-elles utiles ?

Les méthodes magiques sont un concept utile dans la programmation orientée objet en Python. En les utilisant, vous spécifiez le comportement de vos types de données personnalisés lorsqu’ils sont utilisés avec des opérations intégrées courantes. Ces opérations comprennent :

🟢 Opérations arithmétiques

🟢 Opérations de comparaison

🟢 Opérations du cycle de vie

🟢 Opérations de représentation

La section suivante explique comment implémenter des méthodes magiques qui définissent le comportement de l’application lorsqu’elle est utilisée dans toutes les catégories ci-dessus.

Comment définir les méthodes magiques

Comme mentionné précédemment, les méthodes magiques spécifient le comportement des objets. En tant que tels, ils sont définis comme faisant partie de la classe de l’objet. Parce qu’ils font partie de la classe d’objets, ils prennent comme premier argument self qui est une référence à l’objet lui-même.

Ils peuvent accepter des arguments supplémentaires en fonction de la façon dont ils seront appelés par l’interpréteur. Ils sont également définis distinctement avec deux traits de soulignement avant et après leurs noms.

Mise en œuvre

Une grande partie de ce que nous avons discuté jusqu’à présent semble théorique et abstrait. Dans cette section, nous allons implémenter une classe Rectangle simple.

Cette classe aura des propriétés de longueur et de largeur. En utilisant la méthode __init__, vous pouvez spécifier ces propriétés lors de l’instanciation. De plus, vous pourrez comparer différents rectangles pour voir s’il est égal, inférieur ou supérieur à un autre en utilisant les opérateurs ==, < et >. Enfin, le rectangle doit être capable de fournir une représentation sous forme de chaîne significative.

Configuration de l’environnement de codage

Pour suivre cette procédure pas à pas, vous aurez besoin d’un environnement d’exécution Python. Vous pouvez en utiliser un local ou utiliser le compilateur Python toptips.fr en ligne.

Création de la classe Rectangle

Tout d’abord, commençons par définir la classe Rectangle.

class Rectangle:
    pass

Création de la méthode constructeur

Ensuite, créons notre première méthode magique, la méthode du constructeur de classe. Cette méthode prendra la hauteur et la largeur et les stockera en tant qu’attributs sur l’instance de classe.

class Rectangle:
    def __init__(self, height, width):
        self.height = height
        self.width = width

Création d’une méthode magique pour la représentation de chaînes

Ensuite, nous voulons créer une méthode qui permet à notre classe de générer une chaîne lisible par l’homme pour représenter l’objet. Cette méthode sera appelée chaque fois que nous appellerons la fonction str() en passant une instance de la classe Rectangle comme argument. Cette méthode sera également appelée lorsque vous appelez des fonctions qui attendent un argument de chaîne, comme la fonction d’impression.

class Rectangle:
    def __init__(self, height, width):
        self.height = height
        self.width = width

    def __str__(self):
        return f'Rectangle({self.height}, {self.width})'

La méthode __str__() doit renvoyer une chaîne que vous voudriez représenter l’objet. Dans ce cas, nous renvoyons une chaîne au format Rectangle(, ) où hauteur et largeur sont les dimensions stockées du rectangle.

Création de méthodes magiques pour les opérations de comparaison

Ensuite, nous voulons créer des opérateurs de comparaison pour les opérations égal à, inférieur à et supérieur à. C’est ce qu’on appelle la surcharge d’opérateur. Pour les créer, nous utilisons respectivement les méthodes magiques __eq__, __lt__ et __gt__. Ces méthodes renverront une valeur booléenne après avoir comparé les aires des rectangles.

class Rectangle:
    def __init__(self, height, width):
        self.height = height
        self.width = width

    def __str__(self):
        return f'Rectangle({self.height}, {self.width})'

    def __eq__(self, other):
        """ Checking for equality """
        return self.height * self.width == other.height * other.width

    def __lt__(self, other):
        """ Checking if the rectangle is less than the other one """
        return self.height * self.width < other.height * other.width

    def __gt__(self, other):
        """ Checking if the rectage is greater than the other one """
        return self.height * self.width > other.height * other.width

Comme vous pouvez le voir, ces méthodes prennent en compte deux paramètres. Le premier est le rectangle actuel et le second est l’autre valeur à laquelle il est comparé. Cette valeur peut être une autre instance de Rectangle ou toute autre valeur. La logique de la manière dont la comparaison et les conditions dans lesquelles la comparaison renverra vrai dépendent entièrement de vous.

Méthodes magiques courantes

Dans cette prochaine section, nous discuterons des méthodes magiques courantes que vous rencontrerez et utiliserez.

#1. Opérations arithmétiques

Les méthodes magiques arithmétiques sont appelées lorsqu’une instance de votre classe est placée à gauche d’un signe arithmétique. La méthode sera appelée avec deux arguments, le premier étant une référence à l’instance. La deuxième valeur est l’objet à droite du signe. Les méthodes et signes sont les suivants :

NameMethodSignDescriptionAddition__add__+ Ajout d’implémentations. Subtraction__sub__–implémente la soustraction.Multiplication__mul__*implémente la multiplicationDivision__div__/implémente la division.Floor division__floordiv__//implémente la division du sol.

#2. Opérations de comparaison

Comme les méthodes magiques arithmétiques, ces méthodes sont appelées lorsqu’une instance de la classe pour laquelle elles sont définies est placée à gauche de l’opérateur de comparaison. Aussi, comme les méthodes magiques arithmétiques, elles sont appelées avec deux paramètres ; le premier est une référence à l’instance de l’objet. La seconde est une référence à la valeur sur le côté droit du signe.

NameMethodSignDescriptionLess than__lt__Implémente la valeur supérieure à la comparaisonÉgal à__eq__==Implémente la valeur égale à la comparaisonInférieure ou égale à__le__>=Implémente la valeur inférieure ou égale à la comparaisonSupérieur ou égal à__ge__<=Implémente la valeur supérieure ou égale à comparaison

#3. Opérations de cycle de vie

Ces méthodes seront appelées en réponse aux différentes méthodes de cycle de vie d’un objet, telles que l’instanciation ou la suppression. Le constructeur, __init__ appartient à cette catégorie. Les méthodes courantes de cette catégorie sont répertoriées dans le tableau ci-dessous :

NameMethodDescriptionConstructor__init__Cette méthode est appelée chaque fois qu’un objet de la classe pour laquelle elle est définie est supprimé. Elle peut être utilisée pour effectuer des actions de nettoyage telles que la fermeture de tous les fichiers qu’elle avait ouverts.Deletion__del__Cette méthode est appelée chaque fois qu’un objet de la classe pour laquelle elle est définie est supprimé. Il peut être utilisé pour effectuer des actions de nettoyage telles que la fermeture de tous les fichiers qu’il avait ouverts. New__new__La méthode __new__ est appelée en premier lorsqu’un objet de la classe spécifiée est instancié. Cette méthode est appelée avant le constructeur et accepte la classe ainsi que tous les arguments supplémentaires. Il renvoie une instance de la classe. Pour la plupart, ce n’est pas trop utile, mais il est couvert en détail ici.

#4. Opérations de représentation

NameMethodDescriptionStr__str__Retourne une représentation sous forme de chaîne lisible par l’homme de l’objet. Cette méthode est appelée lorsque vous appelez la fonction str(), en passant une instance de la classe comme argument. Il est également appelé lorsque vous transmettez l’instance aux fonctions print() et format(). Il est destiné à fournir une chaîne compréhensible par l’utilisateur final de l’application. Repr__repr__Retourne une représentation sous forme de chaîne de l’objet utilisé par le développeur. Idéalement, la chaîne renvoyée doit être riche en informations afin que vous puissiez construire une instance identique de l’objet à partir de la chaîne uniquement.

Meilleures pratiques pour créer des méthodes magiques

Les méthodes magiques sont incroyables et simplifieront votre code. Cependant, il est important de garder à l’esprit les éléments suivants lorsque vous les utilisez.

• Utilisez-les avec parcimonie – Implémenter trop de méthodes magiques dans vos classes rend votre code difficile à comprendre. Limitez-vous à mettre en œuvre uniquement les éléments essentiels.
• Assurez-vous de comprendre les implications de performances des méthodes telles que __setatrr__ et __getattr__ avant de les utiliser.
• Documentez le comportement de vos méthodes magiques afin que les autres développeurs sachent exactement ce qu’elles font. Cela leur permet de les utiliser plus facilement et de les déboguer si nécessaire.

Derniers mots

Dans cet article, j’ai présenté les méthodes magiques comme moyen de créer des classes pouvant être utilisées avec des opérations intégrées. J’ai également expliqué comment ils sont définis et j’ai passé en revue un exemple de classe implémentée par des méthodes magiques. Ensuite, j’ai mentionné les différentes méthodes que vous allez probablement utiliser et dont vous aurez besoin avant de partager quelques bonnes pratiques à garder à l’esprit.

Ensuite, vous voudrez peut-être apprendre à implémenter la classe Counter en Python.