Comment personnaliser le comportement des classes en Python à l'aide des méthodes magiques

En Python, les classes fournissent un moyen propre de regrouper les données et les fonctionnalités dans des éléments réutilisables. La création de classes personnalisées vous permet de modéliser des entités du monde réel telles que des utilisateurs, des produits et des employés.

Les classes Python définissent des méthodes magiques que vous pouvez personnaliser pour vous permettre de façonner le comportement de vos classes pour des situations uniques.

Comprendre les méthodes magiques

Imaginez les méthodes magiques, également appelées méthodes dunder, comme des sorts secrets ou des chants cachés que Python appelle automatiquement lorsque vous effectuez certaines actions sur un objet.

Python fournit de nombreux comportements intégrés pour les classes via méthodes d'instance, statiques et de classe. Tu peux créer des classes Python, et personnalisez-les encore plus en utilisant des méthodes magiques.

Les méthodes magiques sont des méthodes d'instance en Python qui ont deux traits de soulignement (

__méthode__) avant et après le nom de la méthode.

Ces méthodes spéciales donnent des instructions à Python sur la façon de gérer les objets d'une classe. Voici quelques méthodes magiques couramment utilisées dans les classes Python :

• __gt__: Cette méthode vérifie si un objet est supérieur à un autre.
• __init__: Cette méthode s'exécute lorsque vous créez une instance d'une classe, et elle est principalement destinée à l'initialisation des attributs.
• __str__: Ceci renvoie une représentation sous forme de chaîne de la classe décrivant l'objet.
• __repr__: Cette méthode donne une sortie qui vous permet de recréer l'objet en utilisant évaluation().
• __len__: Lorsque vous utilisez le len() fonction sur un objet, cette méthode renvoie la longueur de l'objet.
• __eq__: Cette méthode permet la comparaison entre objets en utilisant le double égal à (==) opérateur.
• __lt__: Il implémente une comparaison inférieure à (
• __ajouter__: Lorsque vous utilisez l'addition (+) sur les objets, cette méthode s'exécute et effectue des opérations d'addition.
• __obtenir l'article__: Vous permet de récupérer des éléments d'un objet en utilisant la syntaxe d'index, comme obj[clé].

Implémentation de méthodes magiques

La meilleure façon de comprendre les méthodes magiques est de les utiliser.

Représentation sous forme de chaîne d'un objet

Vous pouvez personnaliser la représentation sous forme de chaîne d'un objet pour plus de lisibilité ou pour un traitement ultérieur.

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

Ici vous avez un simple Personne classe avec un __init__ méthode magique pour l’initialiser. Lorsque vous imprimez le p1 objet, il utilise la représentation sous forme de chaîne par défaut fournie par Python.

Pour personnaliser la représentation sous forme de chaîne, définissez le __str__ et __repr__ méthodes magiques :

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78) 
print(p1)

Vous disposez désormais d'une représentation sous forme de chaîne plus lisible et plus complète du p1 objet:

Propriété de longueur d'un objet

Imaginez que, lorsque vous appelez le len() méthode d’un objet Person, vous voulez sa hauteur. Mettre en œuvre le __len__ méthode magique pour le Personne classe:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
p2 = Person('Issac', 25, 89) 
print(len(p2))

Le __len__ La méthode magique renvoie l'attribut de hauteur d'un Personne exemple. Quand vous appelez len (p2), il appellera le __len__ méthode magique automatiquement qui renvoie la hauteur du p2 objet.

Gestion de la comparaison entre les objets

Si vous devez comparer des objets d'une classe en fonction de certaines propriétés de la classe. Vous pouvez définir __eq__ méthode magique et implémentez votre logique de comparaison.

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

Le __eq__ la méthode compare les nom et âge attributs des deux Personne objets pour déterminer l’égalité.

Le double égal à (==) utilise cette méthode pour vérifier l’égalité plutôt que de comparer les identités. donc deux Personne les instances sont égales si elles ont des attributs de nom et d'âge correspondants. Cela vous permet de remplacer le comportement de vérification d'égalité par défaut pour votre classe personnalisée.

En implémentant ces méthodes magiques, vous pouvez définir un comportement personnalisé qui sera cohérent avec les éléments intégrés de Python.

Méthodes magiques avancées

Voici quelques exemples avancés d’utilisation de méthodes magiques pour personnaliser les classes.

Faire en sorte que les classes agissent comme des conteneurs

En utilisant des méthodes magiques, vous pouvez définir des classes qui se comportent comme des conteneurs. Vous pouvez utiliser conteneurs, comme des tuples, pour stocker des collections d'éléments de données. Ils fournissent diverses méthodes pour manipuler, accéder et parcourir les éléments contenus.

classPerson:
def__init__(self):
 self.data = []
def__len__(self):
return len(self.data)
def__getitem__(self, index):
return self.data[index]
def__setitem__(self, index, value):
 self.data[index] = value
def__delitem__(self, index):
del self.data[index]
p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5

Désormais, un objet Person peut se comporter comme un conteneur:

Personnalisation de l'accès aux attributs

En utilisant le __getattr__ méthode magique, vous pouvez personnaliser la façon dont les attributs du Personne la classe est accessible en fonction de certaines conditions.

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

Le __getattr__ La méthode s'exécutera lorsque vous tenterez d'accéder à un attribut qui n'existe pas directement dans l'objet. Dans ce cas, il vérifie si le nom de l'attribut est âge et renvoie 40.

Pour tout autre nom d'attribut, cela génère un Erreur d'attribut avec un message correspondant.

Faire en sorte que les classes se comportent comme des appels

Le __appel__ La méthode vous permet de traiter une instance de la classe comme un objet appelable (c'est-à-dire une fonction).

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

Lorsque vous créez une instance de Additionneur puis appelez-le avec des arguments, le __appel__ La méthode s'exécute et effectue l'addition avant de renvoyer le résultat.

Surcharge de l'opérateur

En utilisant des méthodes magiques, vous pouvez effectuer une surcharge d’opérateurs. La surcharge d'opérateurs vous permet de définir des comportements personnalisés pour les opérateurs intégrés lorsqu'ils sont utilisés avec des instances de vos propres classes. Voici un exemple courant qui explique la surcharge des opérateurs.

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__add__(self, other):
if isinstance(other, Vector):
 new_x = self.x + other.x
 new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")
def__str__(self):
returnf"({self.x}, {self.y})"
# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)
# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)

Le résultat est un nouveau vecteur :

Le Vecteur la classe définit le __ajouter__ méthode, qui s'exécute lorsque vous utilisez la + opérateur entre deux instances de la classe. La méthode ajoute les composantes correspondantes des deux vecteurs et renvoie un nouveau Vecteur exemple avec le résultat.

Ici, vous avez vu les méthodes magiques fondamentales que vous pouvez implémenter pour personnaliser le comportement de votre classe. Python dispose de nombreuses autres méthodes magiques qui offrent plus de flexibilité lors de la création de classes. Se référer au documentation officielle pour une liste complète.

Programmation orientée objet en Python

Les méthodes magiques en Python offrent des moyens puissants de personnaliser et d'améliorer le comportement des classes. Les méthodes magiques vont de pair avec le concept de programmation orientée objet (POO) en Python. Il est donc important de comprendre le concept de POO lorsque l’on essaie d’utiliser des méthodes magiques.