Introduction aux méthodes magiques

Les méthodes magiques, également appelées méthodes dunder (abréviation de « doubles traits de soulignement »), sont des méthodes spéciales de Python qui vous permettent de définir le comportement des objets dans certaines situations.

Dans cette leçon, vous apprendrez à utiliser des méthodes magiques courantes comme __str__, __repr__ et d’autres.

Que sont les méthodes magiques ?

Les méthodes magiques sont des méthodes prédéfinies de Python qui sont appelées automatiquement lorsque des opérations précises sont effectuées sur des objets. Elles sont identifiées par leurs doubles traits de soulignement, comme __init__ ou __str__.

La méthode __init__

La méthode __init__ est un constructeur qui initialise un nouvel objet. Elle est appelée automatiquement lorsqu’un objet est créé :

# Using the __init__ method to initialize attributes
class Person:
    def __init__(self, name, age):
        self.name = name  # Initialize the name attribute
        self.age = age  # Initialize the age attribute

# Creating an instance of Person
person = Person("Alice", 30)
print(person.name, person.age)  # Outputs: Alice 30

La méthode __str__

La méthode __str__ définit la représentation textuelle d’un objet lorsque print() est appelé :

# Defining the __str__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"  # String representation

person = Person("Alice", 30)
print(person)  # Outputs: Name: Alice, Age: 30

La méthode __repr__

La méthode __repr__ fournit une représentation textuelle officielle d’un objet, souvent utilisée pour le débogage :

# Defining the __repr__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"  # Debug-friendly representation

person = Person("Alice", 30)
print(repr(person))  # Outputs: Person('Alice', 30)

Surcharge des opérateurs with les méthodes magiques

Vous pouvez utiliser des méthodes magiques pour personnaliser le comportement d’opérateurs comme + ou == :

# Overloading the + operator with __add__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)  # Adding two points

    def __str__(self):
        return f"({self.x}, {self.y})"

point1 = Point(1, 2)
point2 = Point(3, 4)
result = point1 + point2  # Calls __add__
print(result)  # Outputs: (4, 6)

Méthodes magiques couramment utilisées

Voici quelques méthodes magiques couramment utilisées :

• __len__ : définit le comportement de la fonction len().
• __getitem__ : permet l’indexation comme pour une liste ou un dictionnaire.
• __eq__ : personnalise la comparaison d’égalité à l’aide de ==.

Utiliser __len__ et __getitem__

Vous pouvez utiliser __len__ pour définir la longueur d’un objet personnalisé et __getitem__ pour le rendre indexable :

# Using __len__ and __getitem__ in a custom class
class CustomList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Defines the behavior of len()

    def __getitem__(self, index):
        return self.items[index]  # Enables indexing

custom_list = CustomList([1, 2, 3])
print(len(custom_list))  # Outputs: 3
print(custom_list[1])  # Outputs: 2

Erreurs courantes with les méthodes magiques

Voici quelques erreurs à éviter :

• Définir une méthode magique sans respecter le comportement prévu.
• Surcharger des opérateurs sans nécessité.
• Oublier d’implémenter les méthodes magiques nécessaires dans les types de données personnalisés.

Qu’avez-vous appris ?

Dans cette leçon, vous avez appris :

• Ce que sont les méthodes magiques et pourquoi elles sont utiles.
• Comment utiliser des méthodes magiques courantes comme __init__, __str__ et __repr__.
• Comment surcharger des opérateurs à l’aide de méthodes magiques.

Excellent travail ! Passons au sujet suivant.