Méthodes magiques de base

Introduction

Dans ce tutoriel, nous allons explorer les méthodes magiques de base en Python. Les méthodes magiques, également appelées "dunder" méthodes (méthodes à double tiret bas), vous permettent de définir comment les objets Python se comportent dans certaines situations, permettant une manipulation avancée et personnalisée d'objets.

Initialisation et représentation d'objets

Dans cette section, nous allons explorer les méthodes magiques d'initialisation et de représentation d'objets en Python. Ces méthodes vous permettent de définir un comportement personnalisé pour créer des objets et les représenter sous forme de chaînes de caractères lisibles par l'homme et sans ambiguïté.

__init__

La méthode __init__ est appelée lorsqu'un objet est créé. Elle est utilisée pour initialiser les attributs de l'objet.

Commencons par un objet simple. Dans person.py, créez une classe nommée Person qui ait deux attributs.

class Person:
    def __init__(self, name: str, age: int):
        """
        Initialise l'objet Person avec un nom et un âge.

        :param name: Le nom de la personne.
        :param age: L'âge de la personne.
        """
        self.name = name
        self.age = age

__str__

La méthode __str__ est appelée par la fonction intégrée str() et la fonction print() pour obtenir une représentation sous forme de chaîne de caractères lisible par l'homme de l'objet.

    #... (code précédent dans person.py)

    def __str__(self) -> str:
        """
        Retourne une représentation sous forme de chaîne de caractères lisible par l'homme de l'objet Person.

        :return: Une chaîne décrivant la personne.
        """
        return f"{self.name} a {self.age} ans."

__repr__

La méthode __repr__ est appelée par la fonction intégrée repr() et est utilisée dans l'interpréteur interactif pour obtenir une représentation sous forme de chaîne qui, si possible, peut être utilisée pour recréer l'objet.

    #... (code précédent dans person.py)

    def __repr__(self) -> str:
        """
        Retourne une représentation sous forme de chaîne de l'objet Person qui peut être utilisée pour recréer l'objet.

        :return: Une chaîne au format 'Person(name, age)'.
        """
        return f"Person('{self.name}', {self.age})"

Exemple : Utilisation des méthodes magiques de base

Maintenant que nous avons défini les méthodes magiques de base pour notre classe Person, voyons comment elles fonctionnent dans init_repr_example.py :

from person import Person

## Crée un nouvel objet Person
p = Person("Alice", 30)

## Utilise la méthode __str__ avec la fonction print
print(p)  ## Sortie : Alice a 30 ans.

## Utilise la méthode __repr__ dans l'interpréteur interactif
print(repr(p))  ## Sortie : Person('Alice', 30)

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python init_repr_example.py

Comparaison d'objets

Dans cette section, nous allons explorer les méthodes magiques utilisées pour comparer des objets en Python. Ces méthodes vous permettent de définir une logique de comparaison personnalisée pour les objets de votre classe.

__eq__

La méthode __eq__ est utilisée pour déterminer si deux objets sont égaux. Elle est appelée par l'opérateur ==.

    #... (code précédent dans person.py)

    def __eq__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour égalité.

        :param other: L'autre objet Person à comparer.
        :return: True si les deux objets ont le même nom et le même âge, False sinon.
        """
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

__ne__

La méthode __ne__ est utilisée pour déterminer si deux objets ne sont pas égaux. Elle est appelée par l'opérateur !=.

    #... (code précédent dans person.py)

    def __ne__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour inégalité.

        :param other: L'autre objet Person à comparer.
        :return: True si les objets ont des noms ou des âges différents, False sinon.
        """
        return not self.__eq__(other)

__lt__

La méthode __lt__ est utilisée pour déterminer si un objet est inférieur à un autre. Elle est appelée par l'opérateur <.

    #... (code précédent dans person.py)

    def __lt__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour voir si l'un est inférieur à l'autre en fonction de l'âge.

        :param other: L'autre objet Person à comparer.
        :return: True si l'âge de l'objet actuel est inférieur à l'âge de l'autre objet, False sinon.
        """
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented

__le__

La méthode __le__ est utilisée pour déterminer si un objet est inférieur ou égal à un autre. Elle est appelée par l'opérateur <=.

    #... (code précédent dans person.py)

    def __le__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour voir si l'un est inférieur ou égal à l'autre en fonction de l'âge.

        :param other: L'autre objet Person à comparer.
        :return: True si l'âge de l'objet actuel est inférieur ou égal à l'âge de l'autre objet, False sinon.
        """
        if isinstance(other, Person):
            return self.age <= other.age
        return NotImplemented

__gt__

La méthode __gt__ est utilisée pour déterminer si un objet est supérieur à un autre. Elle est appelée par l'opérateur >.

    #... (code précédent dans person.py)

    def __gt__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour voir si l'un est supérieur à l'autre en fonction de l'âge.

        :param other: L'autre objet Person à comparer.
        :return: True si l'âge de l'objet actuel est supérieur à l'âge de l'autre objet, False sinon.
        """
        if isinstance(other, Person):
            return self.age > other.age
        return NotImplemented

__ge__

La méthode __ge__ est utilisée pour déterminer si un objet est supérieur ou égal à un autre. Elle est appelée par l'opérateur >=.

    #... (code précédent dans person.py)

    def __ge__(self, other: "Person") -> bool:
        """
        Compare deux objets Person pour voir si l'un est supérieur ou égal à l'autre en fonction de l'âge.

        :param other: L'autre objet Person à comparer.
        :return: True si l'âge de l'objet actuel est supérieur ou égal à l'âge de l'autre objet, False sinon.
        """
        if isinstance(other, Person):
            return self.age >= other.age
        return NotImplemented

Exemple : Utilisation des méthodes magiques de comparaison d'objets

Maintenant que nous avons défini les méthodes magiques de comparaison d'objets pour notre classe Person, voyons comment elles fonctionnent dans compare_example.py :

from person import Person

## Crée deux objets Person
p1 = Person("Alice", 30)
p2 = Person("Bob", 35)

## Utilise les méthodes __eq__ et __ne__
print(p1 == p2)  ## Sortie : False
print(p1!= p2)  ## Sortie : True

## Utilise les méthodes __lt__, __le__, __gt__ et __ge__
print(p1 < p2)  ## Sortie : True
print(p1 <= p2)  ## Sortie : True
print(p1 > p2)  ## Sortie : False
print(p1 >= p2)  ## Sortie : False

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python compare_example.py

Destruction d'objets

Dans cette section, nous allons explorer la méthode magique de destruction d'objets en Python. Cette méthode vous permet de définir un comportement personnalisé lorsqu'un objet est sur le point d'être détruit.

__del__

La méthode __del__ est appelée lorsqu'un objet est sur le point d'être détruit. Elle vous permet d'effectuer des tâches de nettoyage, telles que fermer les pointeurs de fichier ou libérer des ressources, avant que l'objet ne soit ramassé par la collecte de déchets.

    #... (code précédent dans person.py)

    def __del__(self):
        """
        Nettoie l'objet Person avant qu'il ne soit détruit.
        """
        print(f"Personne '{self.name}' est en train d'être supprimée.")

Exemple : Utilisation de la méthode magique de destruction d'objets

Maintenant que nous avons défini la méthode magique de destruction d'objets pour notre classe Person, voyons comment elle fonctionne dans del_example.py :

from person import Person

## Crée un objet Person et puis le supprime
p = Person("Alice", 30)
del p  ## Sortie : Personne 'Alice' est en train d'être supprimée.

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python del_example.py

Il est important de noter que la méthode __del__ n'est pas garantie d'être appelée immédiatement lorsqu'un objet n'est plus nécessaire. La suppression effective de l'objet dépend du mécanisme de collecte de déchets de l'interpréteur Python. La méthode __del__ est appelée lorsque le ramasseur de déchets décide d'enlever l'objet de la mémoire.

Résumé

Dans cette série de tutoriels, nous avons exploré les méthodes magiques de Python, également appelées "dunder" méthodes (méthodes à double tiret bas), qui vous permettent de définir des comportements personnalisés pour vos objets dans diverses situations.

En maîtrisant ces méthodes magiques, vous pouvez créer des classes et des objets Python plus puissants et personnalisables. Comprendre et implémenter ces méthodes vous permettra d'écrire du code Python plus efficace, propre et conformé à la PEP 8, rendant vos programmes plus robustes et faciles à maintenir.