Maison > Article > développement back-end > Apprenez les méthodes magiques Python : une explication simple
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.
Ces méthodes magiques contrôlent la manière dont les attributs de vos objets sont consultés, modifiés ou supprimés.
__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__ : 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.
Ces méthodes magiques permettent à vos objets de se comporter comme des conteneurs (listes, dictionnaires, etc.).
__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.
Ces méthodes définissent comment les objets de votre classe interagissent avec les opérations numériques et les comparaisons.
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.
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.
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.
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!