La gestion de la programmation orientée objet par Python
Introduction à la programmation orientée objet en Python
Python est un langage de programmation populaire qui a conquis les développeurs grâce à sa simplicité et sa polyvalence. En plus d’être un bon choix pour la programmation procédurale, Python offre une excellente prise en charge de la programmation orientée objet (POO). Cette approche permet de structurer le code de manière plus claire et réutilisable, facilitant ainsi le développement et la maintenance des logiciels. Dans cet article, nous allons explorer comment Python gère la POO.
Les bases de la programmation orientée objet avec Python : classes et objets
Les classes en Python
Le concept principal de la POO en Python est celui de classes. Une classe est une représentation abstraite d’un objet ou d’une entité du monde réel, contenant des attributs (variables) et des méthodes (fonctions).
Par exemple, supposons que nous voulions modéliser une voiture. Nous pouvons créer une classe “Voiture” contenant des attributs tels que “marque”, “modèle”, “année” et “kilométrage”. À cela, nous ajoutons des méthodes qui décrivent ce que notre voiture peut faire, telles que “accélérer”, “freiner” et “tourner”.
Pour créer une classe en Python, on utilise le mot-clé “class” suivi du nom de la classe et de deux points ( :). Les attributs et méthodes de la classe sont définis à l’intérieur de ce bloc :
class Voiture :
marque = ""
modèle = ""
année = 0
kilométrage = 0
def accélérer(self) :
pass
def freiner(self) :
pass
def tourner(self, direction) :
pass
Lire : Frameworks web populaires Python
Les objets en Python
Une fois que nous avons défini notre classe “Voiture”, nous pouvons utiliser cette structure pour créer des objets, ou instances, de type “Voiture”. Chaque objet représente une voiture particulière avec ses propres valeurs d’attributs et peut exécuter les méthodes définies dans la classe.
Pour créer un nouvel objet de type “Voiture”, nous appelons le nom de la classe comme s’il s’agissait d’une fonction. Par exemple, pour créer une nouvelle voiture de marque “Toyota”, modèle “Corolla” et année “2021”, nous ferions :
ma_voiture = Voiture()
ma_voiture.marque = "Toyota"
ma_voiture.modèle = "Corolla"
ma_voiture.année = 2021
L’encapsulation : regroupement des attributs et méthodes
L’un des principaux avantages de la POO est l’encapsulation, qui consiste à regrouper les attributs et méthodes liés à un objet au sein de sa propre structure. Cela rend le code plus facile à comprendre et à maintenir, car toutes les informations et fonctionnalités liées à un objet sont localisées en un seul endroit.
En Python, on encapsule généralement les attributs et méthodes en les déclarant directement au sein de la classe. Toutefois, pour renforcer l’encapsulation, il est courant d’utiliser des propriétés et des méthodes privées. Les propriétés permettent de contrôler l’accès aux attributs, tandis que les méthodes privées s’assurent qu’une méthode ne peut être appelée que depuis l’intérieur de la classe.
Lire : Comment Python Révolutionne Excel
Les propriétés en Python
En Python, il est possible de contrôler l’accès aux attributs en utilisant des propriétés. Pour cela, on crée des méthodes spéciales, appelées “getter” et “setter”, qui permettent respectivement de lire et de modifier la valeur des attributs.
class Voiture :
# ...
@property
def marque(self) :
return self._marque
@marque.setter
def marque(self, value) :
if not isinstance(value, str) :
raise TypeError("La marque doit être une chaîne de caractères.")
self._marque = value
ma_voiture = Voiture()
ma_voiture.marque = "Toyota" # Appelle le setter
print(ma_voiture.marque) # Appelle le getter
Les méthodes privées en Python
Il est également possible de créer des méthodes privées en Python pour restreindre leur utilisation à l’intérieur de la classe. Pour cela, on peut préfixer le nom de la méthode par un ou deux underscores (_) :
class Voiture :
# ...
def __demarrer_moteur(self) :
pass
def accélérer(self) :
self.__démarrer_moteur()
# ...
Il est important de noter que le “double underscore” n’est pas une véritable protection en Python. Il s’agit plutôt d’une convention qui indique qu’un développeur ne devrait pas utiliser cette méthode en dehors de la classe.
Lire : Dompter les données : Métiers, outils et comment déceler les meilleurs talents
L’héritage : créer des classes dérivées
L’héritage est un autre concept clé en POO, permettant de créer des classes dérivées qui héritent des attributs et méthodes d’une classe parente. Cette technique facilite la réutilisabilité du code et favorise la modularité.
Pour créer une classe dérivée en Python, il suffit d’indiquer la classe parente entre parenthèses après le nom de la nouvelle classe :
class Véhicule :
# ...
class Voiture(Véhicule) :
# ...
Les instances de la classe dérivée auront alors accès aux méthodes et attributs de la classe parente. De plus, il est possible de redéfinir certaines méthodes dans la classe dérivée ou d’en ajouter de nouvelles.
Polymorphisme : interactions entre différentes classes
Le polymorphisme est un concept qui permet aux objets de différentes classes d’être traités comme des objets d’une classe commune. Cela est particulièrement utile lorsqu’on a plusieurs classes dérivées qui partagent certains attributs ou méthodes.
Le polymorphisme peut être réalisé en Python grâce à l’héritage, les classes étant un cas particulier du polymorphisme. En effet, si plusieurs classes dérivent d’une même classe parente, elles peuvent être considérées comme ayant le même type que leur classe parente et donc utilisées de manière interchangeable.
Pour illustrer cela, supposons que nous ayons également une classe “Moto” dérivée de la classe “Véhicule”. Imaginons ensuite que nous ayons une fonction “afficher_vitesse_max” qui prend en argument un objet de type “Véhicule” et affiche sa vitesse maximale :
def afficher_vitesse_max(véhicule) :
print(f"La vitesse maximale de ce véhicule est de {véhicule.vitesse_max} km/h.")
ma_voiture = Voiture()
ma_moto = Moto()
afficher_vitesse_max(ma_voiture)
afficher_vitesse_max(ma_moto)
Cela permet aux instances de “Voiture” et “Moto” d’être passées à la fonction “afficher_vitesse_max” sans problème, car elles sont toutes deux considérées comme des objets de type “Véhicule”. Le polymorphisme facilite ainsi l’interaction entre différents types d’objets