Apprenez les méthodes magiques Python : une explication simple

Comprendre les méthodes magiques en Python

Les

Les méthodes magiques en Python, également connues sous le nom de méthodes dunder (car elles ont des doubles traits de soulignement au début et à la fin de leur nom), nous permettent de définir le comportement de nos objets pour diverses opérations. Ils permettent un comportement personnalisé et peuvent faire en sorte que nos classes agissent comme des types intégrés. Dans ce blog, nous explorerons différentes catégories de méthodes magiques, fournirons des explications détaillées et donnerons des exemples pratiques et des cas d'utilisation.

1. Méthodes d'accès aux attributs

Ces méthodes magiques contrôlent la manière dont les attributs de vos objets sont consultés, modifiés ou supprimés.

__getattr__ et __getattribute__

• __getattr__ : Appelé lorsqu'un attribut n'est pas trouvé dans un objet.

• __getattribute__ : appelé sans condition pour accéder à n'importe quel attribut.

Exemple : accès aux attributs personnalisés avec journalisation

class LoggedAttributes:
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        print(f"Accessing non-existent attribute: {item}")
        return None

    def __getattribute__(self, item):
        print(f"Getting attribute: {item}")
        return super().__getattribute__(item)

# Usage
obj = LoggedAttributes("Alice")
print(obj.name)  # Output: Getting attribute: name\nAlice
print(obj.age)   # Output: Accessing non-existent attribute: age\nNone

Cas d'utilisation pratique : Journalisation de l'accès aux attributs dans un scénario de débogage pour tracer quand et comment les attributs sont accédés ou modifiés.

__setattr__ et __delattr__

• __setattr__ : appelé lorsqu'une attribution d'attribut est tentée.

• __delattr__ : appelé lorsqu'une suppression d'attribut est tentée.

Exemple : Modification d'attribut personnalisé avec validation

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __setattr__(self, key, value):
        if key == "age" and value < 0:
            raise ValueError("Age cannot be negative")
        super().__setattr__(key, value)

    def __delattr__(self, item):
        if item == "name":
            raise AttributeError("Can't delete attribute 'name'")
        super().__delattr__(item)

# Usage
p = Person("Alice", 30)
p.age = 25  # Works fine
# p.age = -1  # Raises ValueError
# del p.name  # Raises AttributeError

Cas d'utilisation pratique : Application de règles ou de restrictions de validation lors de la définition ou de la suppression d'attributs.

2. Méthodes de conteneur

Ces méthodes magiques permettent à vos objets de se comporter comme des conteneurs (listes, dictionnaires, etc.).

__len__, __getitem__, __setitem__, __delitem__ et __iter__

• __len__ : renvoie la longueur du conteneur.

• __getitem__ : récupère un élément à un index ou une clé donnée.

• __setitem__ : définit un élément à un index ou une clé donnée.

• __delitem__ : supprime un élément à un index ou une clé donnée.

• __iter__ : renvoie un objet itérateur.

Exemple : objet de type liste personnalisé

class CustomList:
    def __init__(self):
        self._items = []

    def __len__(self):
        return len(self._items)

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, index, value):
        self._items[index] = value

    def __delitem__(self, index):
        del self._items[index]

    def __iter__(self):
        return iter(self._items)

    def append(self, item):
        self._items.append(item)

# Usage
cl = CustomList()
cl.append(1)
cl.append(2)
cl.append(3)
print(len(cl))  # Output: 3
print(cl[1])    # Output: 2
for item in cl:
    print(item)  # Output: 1 2 3

Cas d'utilisation pratique : Création d'une classe de collection personnalisée qui nécessite un comportement spécialisé ou des méthodes supplémentaires tout en prenant en charge les opérations de liste standard.

3. Méthodes numériques et de comparaison

Ces méthodes définissent comment les objets de votre classe interagissent avec les opérations numériques et les comparaisons.

Méthodes numériques

• __add__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__ : définissez les opérations arithmétiques.

Exemple : Classe de nombres complexes personnalisés

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)

    def __repr__(self):
        return f"({self.real} + {self.imag}i)"

# Usage
c1 = Complex(1, 2)
c2 = Complex(3, 4)
print(c1 + c2)  # Output: (4 + 6i)
print(c1 - c2)  # Output: (-2 + -2i)

Cas d'utilisation pratique : Implémentation de types numériques personnalisés tels que des nombres complexes, des vecteurs ou des matrices.

Méthodes de comparaison

• __eq__, __ne__, __lt__, __le__, __gt__, __ge__ : définir les opérations de comparaison.

Exemple : implémentation du classement total pour une classe personnalisée

from functools import total_ordering

@total_ordering
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __eq__(self, other):
        return (self.title, self.author) == (other.title, other.author)

    def __lt__(self, other):
        return (self.title, self.author) < (other.title, other.author)

    def __repr__(self):
        return f"{self.title} by {self.author}"

# Usage
book1 = Book("Title1", "Author1")
book2 = Book("Title2", "Author2")
books = [book2, book1]
print(sorted(books))  # Output: [Title1 by Author1, Title2 by Author2]

Cas d'utilisation pratique : Permet de trier ou de comparer des objets personnalisés, utile dans les structures de données telles que les tas, les arbres de recherche binaires ou simplement lors du tri de listes d'objets personnalisés.

4. Méthodes de conteneurs : cas d'utilisation pratique

Dictionnaire personnalisé avec touches insensibles à la casse

Création d'un objet de type dictionnaire qui traite les clés comme insensibles à la casse.

Exemple : Dictionnaire insensible à la casse

class CaseInsensitiveDict:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        return self._data[key.lower()]

    def __setitem__(self, key, value):
        self._data[key.lower()] = value

    def __delitem__(self, key):
        del self._data[key.lower()]

    def __contains__(self, key):
        return key.lower() in self._data

    def keys(self):
        return self._data.keys()

    def items(self):
        return self._data.items()

    def values(self):
        return self._data.values()

# Usage
cid = CaseInsensitiveDict()
cid["Name"] = "Alice"
print(cid["name"])  # Output: Alice
print("NAME" in cid)  # Output: True

Cas d'utilisation pratique : Création de dictionnaires où les clés doivent être traitées comme insensibles à la casse, utiles pour gérer les entrées utilisateur, les paramètres de configuration, etc.

Conclusion

Les méthodes magiques offrent un moyen puissant de personnaliser le comportement de vos objets en Python. Comprendre et utiliser efficacement ces méthodes peut rendre vos classes plus intuitives et s'intégrer de manière transparente aux fonctions et opérateurs intégrés de Python. Que vous implémentiez des types numériques personnalisés, des conteneurs ou des modèles d'accès aux attributs, les méthodes magiques peuvent considérablement améliorer la flexibilité et les fonctionnalités de votre code

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!