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

L’une des fonctionnalités les moins connues de Python, mais néanmoins précieuse, est la possibilité d’implémenter des méthodes magiques sur les objets. Les méthodes magiques permettent d’écrire un code plus propre, intuitif et facile à comprendre.

Avec les méthodes magiques, nous pouvons créer des interfaces pour interagir avec les 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 les plus 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 définies distinctement par des doubles traits de soulignement avant et après le nom de la méthode.

C’est pourquoi elles sont communément appelées méthodes dunder, comme dans double underscore. L’une de ces méthodes que vous avez peut-être déjà rencontrée est la méthode __init__( ), 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 ; elles sont plutôt appelées par l’interpréteur lors de 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. Elles vous permettent de spécifier 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 :

🟢 les opérations arithmétiques

🟢 les opérations de comparaison

🟢 les opérations sur le cycle de vie

🟢 Opérations de représentation

La section suivante explique comment mettre en œuvre des méthodes magiques qui définissent le comportement de l’application lorsqu’elle est utilisée dans toutes les catégories susmentionnées.

Comment définir les méthodes magiques

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

Ils peuvent prendre des arguments supplémentaires en fonction de la manière dont ils seront appelés par l’interprète. Elles sont également définies de manière distincte par deux traits de soulignement avant et après leur nom.

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. En outre, vous serez en mesure de comparer différents rectangles pour voir s’ils sont égaux, inférieurs ou supérieurs à un autre en utilisant les opérateurs ==, < et >. Enfin, le rectangle doit être capable de fournir une représentation significative sous forme de chaîne de caractères.

Mise en place de l’environnement de codage

Pour suivre ce guide, vous aurez besoin d’un environnement d’exécution Python. Vous pouvez utiliser un environnement local, ou vous pouvez utiliser le compilateur Python en ligne de Geekflare.

Création de la classe Rectangle

Commençons par définir la classe Rectangle.

classe Rectangle :
    pass

Création de la méthode de construction

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

classe Rectangle :
    def __init__(self, height, width) :
        self.height = hauteur
        self.width = largeur

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

Ensuite, nous voulons créer une méthode qui permette à notre classe de générer une chaîne de caractères 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 appellerez des fonctions qui attendent un argument de type chaîne de caractères, comme la fonction print.

classe Rectangle :
    def __init__(self, height, width) :
        self.height = hauteur
        self.width = largeur

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

La méthode __str__() doit renvoyer une chaîne de caractères que vous souhaitez pour représenter l’objet. Dans ce cas, nous renvoyons une chaîne au format Rectangle(<hauteur>, <largeur>) où la hauteur et la 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 des opérateurs. Pour les créer, nous utilisons les méthodes magiques __eq__, __lt__ et __gt__ respectivement. Ces méthodes renvoient une valeur booléenne après avoir comparé les surfaces des rectangles.

classe Rectangle :
    def __init__(self, height, width) :
        self.height = hauteur
        self.width = largeur

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

    def __eq__(self, other) :
        """ Vérification de l'égalité """
        return self.height * self.width == other.height * other.width

    def __lt__(self, other) :
        """ Vérifie si le rectangle est plus petit que l'autre """
        return self.height * self.width < other.height * other.width

    def __gt__(self, other) :
        """ Vérifie si le rectangle est plus grand que l'autre """
        return self.height * self.width > other.height * other.width

Comme vous pouvez le constater, 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 comparaison et les conditions dans lesquelles la comparaison renvoie un résultat positif sont entièrement laissées à votre discrétion.

Méthodes magiques courantes

Dans la section suivante, nous allons discuter des méthodes magiques les plus 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 est appelée avec deux arguments, le premier étant une référence à l’instance. La seconde valeur est l’objet situé à droite du signe. Les méthodes et les signes sont les suivants :

Nom	Méthode	Signe	Description
Addition	`__add__`		Met en œuvre l’addition.
Soustraction	`__sub__`	–	Implémente la soustraction.
Multiplication	`__mul__`	*	Implémente la multiplication
Division	`__div__`	/	Met en œuvre la division.
Division par étage	__floordiv__	//	Met en œuvre la division en étages.

#2. Opérations de comparaison

Comme les méthodes arithmétiques magiques, 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. De même, comme les méthodes arithmétiques magiques, elles sont appelées avec deux paramètres ; le premier est une référence à l’instance de l’objet. Le second est une référence à la valeur située à droite du signe.

Nom de la méthode	Méthode	Signe	Description de la méthode
Inférieur à	`__lt__`	`<`	Met en œuvre la comparaison “moins que”
Plus grand que	`__gt__`	`>`	Implémente la comparaison plus grand que
Égal à	`__eq__`	`==`	Implémente la comparaison égal à
Inférieur ou égal à	`__le__`	`>=`	Implémente la comparaison inférieur ou égal à
Supérieur ou égal à	`__ge__`	`<=`	Implémente la comparaison plus grand que ou égal à

#3. Opérations sur le 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__ fait partie de cette catégorie. Les méthodes courantes de cette catégorie sont énumérées dans le tableau ci-dessous :

Nom	Méthode	Description
Constructeur	`__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 des fichiers ouverts.
Suppression	`__del__`	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 des fichiers qu’il a ouverts.
Nouveau	__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 prend en compte la classe ainsi que d’éventuels arguments supplémentaires. Elle renvoie une instance de la classe. Dans l’ensemble, elle n’est pas très utile, mais elle est couverte en détail ici.

#4. Opérations de représentation

Nom de la méthode	Méthode	Description
Str	__str__	Renvoie une représentation sous forme de chaîne de caractères 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. Elle est également appelée lorsque vous transmettez l’instance aux fonctions `print()` et `format()`. Elle est destinée à fournir une chaîne de caractères compréhensible par l’utilisateur final de l’application.
Repr	__repr__	Renvoie une représentation sous forme de chaîne de caractères de l’objet qui est utilisée par le développeur. Idéalement, la chaîne renvoyée devrait être riche en informations, de sorte que vous puissiez construire une instance identique de l’objet à partir de la seule chaîne.

Bonnes pratiques pour la création de méthodes magiques

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

Utilisez-les avec parcimonie – L’implémentation d’un trop grand nombre de méthodes magiques dans vos classes rend votre code difficile à comprendre. Limitez-vous à l’implémentation des méthodes essentielles.
Assurez-vous de comprendre les implications en termes de performances de 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. Il leur sera ainsi plus facile de les utiliser et de les déboguer si nécessaire.

Mot de la fin

Dans cet article, j’ai présenté les méthodes magiques comme un moyen de créer des classes pouvant être utilisées avec des opérations intégrées. J’ai également discuté de la façon dont elles sont définies et j’ai donné un exemple de classe dans laquelle les méthodes magiques sont implémentées. 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 comment implémenter la classe Counter en Python.