De nombreux développeurs peinent à définir et utiliser correctement les classes et leurs attributs en programmation orientée objet (POO), entraînant une structuration inefficace du code.
Sans une compréhension claire des concepts de classes et méthodes spéciales, le code devient difficile à maintenir, à déboguer et à faire évoluer, causant une perte de temps et de ressources.
Cet article vous offre un guide pratique pour maîtriser les classes, les attributs et les méthodes spéciales, optimisant ainsi la qualité et l’efficacité de votre code.
Définir une classe et ses attributs en Python
Définir une classe en Python
Commençons par apprendre à définir une classe et ses attributs en programmation orientée objet (POO). Une classe peut être comparée à un modèle qui nous permet de créer des objets, tout comme un moule à gâteau permet de créer des gâteaux.
Pour déclarer une classe, on utilise le mot-clé class suivi du nom de notre classe et de deux points, comme illustré dans l’exemple suivant :
Ici, nous avons créé une classe vide, donc nous devons nécessairement écrire le mot-clé pass pour indiquer qu’il n’y a pas encore de contenu.
Si nous écrivons print(Voiture) après avoir créé un objet Voiture, l’objet de cette classe sera affiché comme il est montré dans l’exemple suivant.
Définir les attributs d'une classe en Python
Après avoir créé notre classe Voiture, nous allons maintenant définir les attributs de cette classe, qui sont simplement des variables propres à la classe. Par exemple, nous pouvons définir les attributs marque ,modele , nbre_roue et couleur, comme il est montré dans l’exemple suivant :
class Voiture:
marque = "Toyota"
modele = "Corolla"
nbre_roues = 4
couleur = "rouge"
Pour afficher la valeur des attributs de notre classe, nous devons utiliser la syntaxe suivante :
print(Voiture.marque)
print(Voiture.modele)
print(Voiture.nbre_roues)
print(Voiture.couleur)
Et voici le résultat afficher par l’exemple précèdent :
Toyota
Corolla
4
rouge
Instancier une classe en Python
Créer une instance d'une classe en Python
Après avoir appris comment accéder aux attributs d’une classe, nous allons maintenant voir comment instancier une classe. De la même manière qu’un moule permet de créer plusieurs gâteaux, une classe peut générer plusieurs objets. Pour instancier un nouvel objet, vous suivez les étapes suivantes :
class Voiture:
marque = "Honda"
modele = "Civic"
annee = 2018
Dans cet exemple, la classe `Voiture` contient trois attributs : marque, modele, et annee, qui sont définis directement au niveau de la classe.Pour accéder à ces attributs, vous pouvez instancier un objet de la classe Voiture comme il est montrer dans l’exemple suivant :
class Voiture:
marque = "Honda"
modele = "Civic"
annee = 2018
ma_voiture = Voiture()
print(ma_voiture.marque) # Affiche: Honda
print(ma_voiture.modele) # Affiche: Civic
print(ma_voiture.annee) # Affiche: 2018
Vous pouvez également accéder aux attributs directement depuis la classe sans créer d’objet :
print(Voiture.marque) # Affiche: Honda
print(Voiture.modele) # Affiche: Civic
print(Voiture.annee) # Affiche: 2018
Pour mieux comprendre la différence entre une classe et ses objets, voici un schéma qui illustre la classe « Voiture » ainsi que les objets « Objet 1 », « Objet 2 », « Objet 3 », et « Objet 4 ».
Utiliser les méthodes d'instance en Python
Après avoir vu comment instancier une classe et accéder à ses attributs, passons maintenant à la définition et l’utilisation des méthodes d’instance. Les méthodes d’instance sont le type de méthode le plus couramment utilisé lorsqu’on travaille avec des objets en Python. Elles permettent de manipuler les données propres à chaque instance d’une classe et sont essentielles pour la plupart des opérations orientées objet.
Nous allons commencer par créer une méthode appelée rouler pour la classe Voiture. Il est important de noter que le paramètre self doit être passé en premier dans notre méthode. Ce paramètre fait référence à l’instance actuelle de la classe. Si self n’est pas inclus, une erreur sera levée.Voici le code de notre classe :
class Voiture:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele
self.kilometrage = 0
def rouler(self, distance):
"""Cette méthode permet de faire rouler la voiture d'une certaine distance."""
self.kilometrage += distance
print(f"La {self.marque} {self.modele} a roulé {distance} km. Kilométrage total : {self.kilometrage} km.")
# Instanciation d'un objet de la classe Voiture
ma_voiture = Voiture("Toyota", "Corolla")
# Utilisation de la méthode d'instance rouler
ma_voiture.rouler(150)
Développez des applications robustes avec la POO en Python !
Comprendre le mot-clé self en Python
Le mot-clé `self` est un élément fondamental en Python lorsqu’on travaille avec des classes et des objets. Il est utilisé pour faire référence à l’instance actuelle de la classe, c’est-à-dire à l’objet lui-même. Lorsqu’une méthode d’instance est définie dans une classe, `self` est toujours le premier paramètre de la méthode. Grâce à `self`, on peut accéder aux attributs et autres méthodes de l’objet à partir de cette méthode. En d’autres termes, `self` permet à une méthode de manipuler les données spécifiques à l’objet sur lequel elle a été appelée.
class Voiture:
marque = "Toyota"
modele = "Corolla"
annee = 2020
def rouler(self):
print(f"La {self.marque} {self.modele} de {self.annee} est en train de rouler.")
ma_voiture = Voiture()
ma_voiture.rouler()
Dans ce code, nous définissons une classe Voiture avec trois attributs de classe : marque, modele, et annee, qui sont définis avec des valeurs par défaut. Ces attributs sont partagés par toutes les instances de la classe. La classe inclut également une méthode d’instance appelée rouler. La méthode rouler utilise le mot-clé self pour accéder aux attributs de l’instance courante et affiche un message indiquant que la voiture est en train de rouler. Ensuite, nous créons une instance de la classe Voiture nommée ma_voiture. Enfin, nous appelons la méthode rouler sur cette instance, ce qui affiche un message avec les valeurs des attributs marque, modele, et annee de l’objet ma_voiture, comme il est montré dans la figure suivante :
Les méthodes spéciales en Python
Qu'est-ce qu'une méthode spéciale en Python ?
Les méthodes spéciales en Python, également connues sous le nom de méthodes magiques, permettent de personnaliser le comportement des objets lors de certaines opérations intégrées.
Les méthodes spéciales, aussi appelées méthodes magiques ou dunder methods, sont des méthodes intégrées dans les classes Python qui commencent et se terminent par deux underscores (__). Elles permettent de personnaliser le comportement des objets pour certaines opérations intégrées.
Ainsi Voici un tableau qui récapitule quelque méthode les plus fréquemment utilisée en python :
les méthodes | Description | code |
|---|---|---|
__init__ | Constructeur de la classe ; initialise l’objet
| def __init__(self, nom): self.nom = nom
|
__str__ | Représentation sous forme de chaîne (utilisé par print) | def __str__(self): return self.nom
|
__repr__ | Représentation détaillée de l’objet pour le débogage | def __repr__(self): return f’Person({self.nom})’ |
__len__
| Retourne la longueur ou le nombre d’éléments | def __len__(self): return len(self.items) |
__getitem__ | Accès aux éléments par index ou clé | def __getitem__(self, index): return self.items[index] |
__eq__ | Comparaison d’égalité (==) | def __eq__(self, other): return self.nom == other.nom
|
__call__ | Permet de rendre l’objet callable comme une fonction | def __call__(self, x): return self.value * x
|
Méthode spéciale __str__ en Python
Par exemple, dans la classe Voiture, si nous n’avons pas défini de méthode spéciale, l’appel de print(ma_voiture) affichera par défaut l’adresse mémoire de l’objet, ce qui n’est pas très informatif. Pour améliorer cette présentation, nous pouvons définir la méthode spéciale __str__ en utilisant le mot-clé def, avec la syntaxe suivante :
def __str__(self):
return self.marque
Ainsi, lorsque nous utilisons print(ma_voiture), la méthode __str__ est appelée et affiche la marque de la voiture plutôt que l’adresse mémoire. Il est possible de retourner n’importe quel attribut ou chaîne de caractères dans __str__.
Utiliser la méthode spéciale len() en Python
Si nous essayons d’utiliser len(ma_voiture), nous obtiendrons une erreur car les objets ne possèdent pas de méthode de longueur par défaut. Pour remédier à cela, nous pouvons définir la méthode spéciale __len__ de la manière suivante :
def __len__(self):
return len(self.marque)
Avec cette méthode, len(ma_voiture) renverra la longueur de la chaîne self.marque. En définissant ces méthodes spéciales, nous pouvons personnaliser la façon dont nos objets sont affichés et manipulés dans diverses opérations intégrées.
Le constructeur de classe __init__ en Python
le constructeur de classe est utilisé pour initialiser les attributs d’une instance lors de sa création. Il fait appel à une méthode spéciale, appelée __init__, qui accepte le paramètre self pour faire référence à l’instance en cours, comme illustré dans l’exemple suivant :
class Formateurs:
def __init__(self, nom, prenom, matiere):
self.nom = nom
self.prenom = prenom
self.matiere = matiere
Dans cet exemple, nous avons la classe Formateurs, qui possède les attributs nom, prenom, et matiere. Lorsque nous instancions un nouvel objet de cette classe, il est nécessaire de fournir des valeurs pour tous ces attributs. Par exemple :
formateur1 = Formateurs("Dupont", "Jean", "Mathématiques")
Si ces attributs ne sont pas initialisés correctement, une erreur sera levée, comme le montre l’exemple ci-dessous :
Le destructeur de classe __del__ en Python
En Python, le destructeur de classe est une méthode spéciale qui s’occupe de nettoyer les ressources lorsque l’objet est sur le point d’être détruit. Cette méthode magique est appelée __del__ et est définie de manière similaire au constructeur __init__. Toutefois, contrairement à des langages comme le C++ où vous devez gérer la mémoire manuellement, Python intègre un mécanisme de gestion automatique de la mémoire appelé ramassage des ordures (garbage collection). Ce système s’occupe de libérer la mémoire des objets non utilisés sans intervention de votre part. Le destructeur __del__ est appelé lorsque l’objet est sur le point d’être détruit, généralement lorsque le programme se termine ou que l’objet n’est plus référencé. Voici un exemple de classe avec un destructeur :
class Tableau:
def __init__(self):
self.data = [1] * 50
def __del__(self):
print("Je suis le destructeur...")
self.data.clear()
t = Tableau()
print(t.data)
Dans cet exemple, la méthode __del__ est définie pour afficher un message et nettoyer les données lorsque l’objet t est détruit. La sortie du programme affichera le contenu de t.data avant que le destructeur ne soit invoqué. Notez que le moment précis où __del__ est appelé peut dépendre de la gestion de la mémoire par le garbage collector, ce qui peut varier d’une exécution à l’autre.
Les dataclasses en Python
Les dataclasses sont simples à lire et à écrire, comme le montre l’exemple suivant :
- Avant l’introduction des dataclasses :
class Users:
def __init__(self, username, password, id):
self.username = username
self.password = password
self.id = id
u = Users("bill", "mpass", 123)
print(u.username)
Dans l’exemple ci-dessus, on peut constater que la définition de la classe Users et l’instanciation peuvent être un peu longues et répétitives.
Avec les dataclasses, cette tâche est simplifiée. On commence par importer dataclass depuis le module dataclasses comme il est montré dans la figure suivante :
from dataclasses import dataclass
Ensuite, on utilise le décorateur @dataclass pour indiquer que la classe est une dataclass. On peut alors définir la classe de manière plus concise :
from dataclasses import dataclass
@dataclass
class Users:
username: str
password: str
id: int
u = Users("bill", "mpass", 123)
print(u.username)
Avec cette approche, la classe Users est plus lisible et plus facile à écrire. Le décorateur @dataclass gère automatiquement les méthodes spéciales telles que __init__, __repr__, et __eq__, ce qui simplifie considérablement la gestion des données au sein de la classe.Les dataclasses permettent également d’ajouter des valeurs par défaut pour les attributs, ce qui peut rendre la définition de la classe encore plus flexible.Voici comment vous pouvez définir des valeurs par défaut dans une dataclass:
Dans cet exemple :
- username, password, et id ont des valeurs par défaut.
- Lorsqu’on crée une instance de Users sans spécifier ces valeurs, les valeurs par défaut sont utilisées.
Cela vous permet de créer des objets avec des valeurs par défaut tout en ayant la possibilité de spécifier des valeurs personnalisées lorsque nécessaire.
Utiliser une méthode statique en Python
Une méthode statique dans une classe est une méthode qui ne dépend ni des attributs de la classe ni de ses méthodes d’instance. Elle peut être appelée directement sur la classe sans avoir besoin de créer une instance de celle-ci. Contrairement aux méthodes d’instance et aux méthodes de classe, une méthode statique n’a pas accès aux attributs ou aux méthodes de la classe.
Voici comment vous pouvez définir et utiliser une méthode statique :
- Définition d’une méthode statique : Utilisez le décorateur @staticmethod pour indiquer qu’une méthode est statique. Elle ne prend pas de paramètre spécial comme self ou cls.
- Appel de la méthode statique : Vous pouvez appeler une méthode statique directement sur la classe sans avoir besoin d’instancier un objet.
Voici un exemple pour illustrer cela :
class Eleve:
def __init__(self, nom, note):
self.nom = nom
self.note = note
def info(self):
print(f"Nom : {self.nom}\nNote : {self.note}")
@staticmethod
def resultat(note):
if note > 10:
print("Admis")
else:
print("Non admis")
# Création d'une instance de la classe
e1 = Eleve("Parrin", 9)
e1.info()
# Appel de la méthode statique
Eleve.resultat(12) # Affiche : Admis
Eleve.resultat(8) # Affiche : Non admis
Voici le résultat retourner par ce code :
Nom : Parrin
Note : 9
Admis
Non admis
Dans cet exemple :
- resultat est une méthode statique, donc elle est définie avec le décorateur @staticmethod et ne prend pas self ou cls comme paramètre.
- La méthode resultat peut être appelée directement sur la classe Eleve sans créer une instance de celle-ci.
- Les méthodes statiques sont utiles lorsque vous souhaitez regrouper des fonctions dans une classe qui ne nécessitent pas l’accès aux attributs ou aux autres méthodes de la classe.
Voici quelques avantages de l’utilisation des méthodes statiques dans votre code :
Méthode de classe en Python
Les méthodes de classe sont liées à la classe elle-même, tandis que les méthodes d’instance sont associées aux objets créés à partir de la classe. Supposons que nous avons une classe Ordinateur avec un constructeur qui prend deux attributs : marque et modele. En plus, la classe possède un attribut de classe stock qui doit être décrémenté chaque fois qu’une méthode de vente est appelée. Voici comment on peut gérer cela :
Avant l’utilisation des méthodes de classe, nous aurions quelque chose comme ceci :
class Ordinateur:
stock = 50 # Attribut de classe
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele
def venteordi(self):
if Ordinateur.stock > 0:
Ordinateur.stock -= 1
else:
print("Stock épuisé")
# Instanciation d'un objet
o = Ordinateur("Dell", "XPS")
# Appel de la méthode d'instance
o.venteordi()
print(Ordinateur.stock) # Affiche : 49
# Appel de la méthode d'instance à nouveau
o.venteordi()
print(Ordinateur.stock) # Affiche : 48
Pour résoudre ce problème et garantir que l’attribut stock est modifié de manière cohérente à travers toutes les instances, on fait recours à une méthode de classe. Cette méthode est clairement liée à la classe elle-même plutôt qu’à une instance spécifique, permettant ainsi une gestion centralisée et cohérente des attributs partagés par toutes les instances.
Voici comment vous pouvez modifier la méthode venteordi pour en faire une méthode de classe :
class Ordinateur:
stock = 50 # Attribut de classe
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele
@classmethod
def venteordi(cls):
if cls.stock > 0:
cls.stock -= 1
else:
print("Stock épuisé")
# Instanciation d'un objet
o = Ordinateur("Dell", "XPS")
# Appel de la méthode de classe
Ordinateur.venteordi()
print(Ordinateur.stock) # Affiche : 49
# Appel de la méthode de classe à nouveau
Ordinateur.venteordi()
print(Ordinateur.stock) # Affiche : 48
La méthode venteordi est maintenant une méthode de classe, indiquée par le décorateur @classmethod. Ainsi, les modifications apportées à stock affectent toutes les instances de la classe, car elles se réfèrent toutes au même attribut de classe.
Voici quelques avantages de l’utilisation des méthodes de classe dans votre code :
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui. Découvrez des cours variés pour tous les niveaux !
Conclusion
En maîtrisant les classes Python, vous avez désormais une solide compréhension de l’un des piliers de la programmation orientée objet. La création de classes et l’utilisation des méthodes spéciales permettent de structurer efficacement vos programmes et d’améliorer la réutilisabilité de votre code.
Que ce soit pour définir des attributs, gérer les méthodes statiques ou manipuler les objets, les classes Python offrent une grande flexibilité et puissance. Continuez à explorer ces concepts pour développer des applications robustes et évolutives.
