.
- Le concept de POO en Python
- Terminologie de la POO
- Les classes en Python
- Les méthodes d'instances en POO Python
- Les méthodes de classes en Python
- Attributs d'instances et attributs de classes
- Les méthodes statiques
- Héritage en POO Python
- Héritage multiple
- Surcharge de méthodes (overloading)
- Polymorphisme et redéfinition de méthodes (overriding methods)
- Les classes abstraites en Python
- Les interfaces en Python
1. Le concept de POO en Python
La programmation orientée objet (POO) est un type de programmation permettant de structurer un programme en regroupant des propriétés et des comportements associés dans des objets appelés objets d'instances.
Conceptuellement, les objets sont comme les composants d'un système. Considérez un programme comme une sorte de chaîne de montage en usine. À chaque étape de la chaîne de montage, un composant du système traite un matériau, transformant finalement la matière première en un produit fini.
En d'autres termes, la programmation orientée objet est une approche permettant ayant pour but de modéliser des éléments du monde réel comme: voitures, personnes etc. ainsi que des relations entre des entités telles que les entreprises et les employés, les étudiants et les enseignants, etc. La modélisation POO modélise des entités réelles sous la forme d'objets logiciels certaines données qui leur sont associées et peuvent remplir certaines fonctions.
La programmation orienté objet est un type de programmation basée sur la création des classes et des objets via une opération appelée instanciation. Une classe est un prototype (modèle) codé en un langage de programmation dont le but de créer des objets dotés d'un ensemble de méthodes et attributs qui caractérisent n'importe quel objet de la classe. Les attributs sont des types de données (variables de classe et variables d'instance) et des méthodes, accessibles via la concaténation par points. En programmation orientée objet, la déclaration d'une classe regroupe des méthodes et propriétés (attributs) communs à un ensemble d'objets. Ainsi on pourrait dire qu'une classe représente une catégorie d'objets. Elle apparaît aussi comme une usine permettant de créer des objets ayant un ensemble d'atributs et méthodes communes.
Dès sa création, Python est un langage orienté objet. Pour cette raison, la création et l'utilisation de classes et d'objets sont carrément faciles. Dans ce chapitre, nous allons traiter la notion de programmation orientée objet en Python ainsi que toutes les conceptes liés: classes & objet d'instance, héritage, polymorphisme, surcharge de méthodes etc.
2. Terminologie de la POO
- Classe: modèle de code abstrait qui représente et caractérise une catégorie d'objets ayant des propriétés communes (attributs et méthodes). La création d'un objet à partir d'une classe est appelé instanciation. L'objet crée à partir d'une classe est appelé instance ou objet d'instance ( instance object en anglais)
- Variable de classe: Variable partagée par toutes les instances d'une classe. Les variables de classe sont définies dans une classe mais en dehors de toute méthode de la classe. Les variables de classe ne sont pas utilisées aussi souvent que les variables d'instance.
- Data member: Une variable de classe ou une variable d'instance qui contient les données associées à une classe et à ses objets.
- Surcharge de fonction (Function overloading): Affectation de plusieurs comportements à une fonction particulière. L'opération effectuée varie en fonction des types d'objets ou d'arguments impliqués.
- Variable d'instance: Variable définie dans une méthode et n'appartenant qu'à l'instance actuelle d'une classe.
- Héritage: Transfert des caractéristiques d'une classe à d'autres classes qui en sont dérivées.
- Instance: Un objet crée à partir d'une certaine classe. Un objet obj qui appartient à une classe Circle, par exemple, est une instance de la classe Circle.
- Instanciation: Création d'une instance d'une classe.
- Méthode: Type particulier de fonction défini dans une définition de classe.
- Object: Une instance unique d'une structure de données définie par sa classe. Un objet comprend à la fois des membres de données (variables de classe et variables d'instance) et des méthodes.
- Surcharge: Affectation de plusieurs fonctions à un opérateur particulier.
3. Les classes en Python
Pour créer une classe en Python, on utilise le mot clé 'class' suivie du nom de la classe à créer:
|
1 |
class nom_de_la_classe: |
On crée ensuite une méthode qui permet de construire les objets, appelé constructeur via l'instruction :
|
1 2 |
def __init__(self): ... |
Exemple (classe Personne)
|
1 2 3 4 5 6 7 8 9 |
class Personne: def __init__(self,nom,age): self.nom = nom self.age = age P = Personne("Albert",27) print("Le nom de la prsonne est : " , P.nom) print("L'age de la personne est : " , P.age, " ans") # affiche : Le nom de la prsonne est : Albert # L'age de la personne est : 27 ans |
Exemple (classe Rectangle)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class Rectangle: def __init__(self,L,l): self.Longueur=L self.Largeur=l monRectangle=Rectangle(7,5) print("La longueur de mon rectangle est : ",monRectangle.Longueur) print("La largeur de mon rectangle est : ",monRectangle.Largeur) """ Ce qui affiche à l'exécution : La longueur de mon rectangle est : 7 La largeur de mon rectangle est : 5 """ |
On peut aussi améliorer la classe en ajoutant des méthodes permettant d'effectuer différentes tâches comme: méthodes d'instance, méthodes de classe...
4. Les méthodes d'instances en POO Python
Definition Une méthode d'instance est une méthode ou procédure nommée au sein de la classe, permettant de définir des propriétés ou comportements des objets d'instances. Une méthode d'instance possède un ou plusieurs paramètre, le premier nommé self est obligatoire!
Exemple (ajout de méthode d'instance qui calcule la surface du rectangle)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class Rectangle: def __init__(self,L,l): self.Longueur=L self.Largeur=l # méthode qui calcule la surface def surface(self): return self.Longueur*self.Largeur # création d'un rectangle de longueur 7 et de largeur 5 monRectangle = Rectangle(7,5) print("La surface de mon rectangle est : ", monRectangle.surface()) #Ce qui affiche après exécution : La surface de mon rectangle est : 35 |
5. Les méthodes de classes en Python
Une méthode de classe en Python est une méthode qui fonctionne au sein de la classe où elle a été crée et elle est accessible par un objet d'instance ou directement en utilisant le nom de la classe sans faire aucune instanciation! Une méthode de classe est caractérisée par:
- Elle fonctionne à l'intérieur de la classe où elle a été et est accessible via une instance objet ou en utilisant le nom de la classe!
- Une méthode de classe est décorée par @classmethod
- Une méthode de classe possède un premier paramètre obligatoire nommé cls
6. Attributs d'instances et attributs de classes
Un attribut d'instance est un attribut qui fonctionne avec un objet d'instance tandis qu'un attribut de classe est un attribut qui fonctionne avec la classe.
Exemple (attributs d'instances & attributs de classes)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
class Student: name = 'Aladin' # attribut de classe def __init__(self , age): self.age = 30 # attribut d'instance @classmethod def displayName(cls): print("Le nom de l'etudiant est:" , cls.name) Stud = Student(22) Student.displayName()# affiche: Le nom de l'etudiant est: Aladin print("La méthode de classe est aussi accéssible via un objet d'instance :") Stud.displayName()# affiche: Le nom de l'etudiant est: Aladin """ output: Le nom de l'etudiant est: Aladin La méthode de classe est aussi accéssible via un objet d'instance : Le nom de l'etudiant est: Aladin """ |
Voici un autre exemple qui explique clairement comment utiliser les attributs et méthodes de classe:
Il s'agit d'un exemple de classe 'Voiture' qui contient un attribut de classe nommé nombre_de_voitures ( variable de classe) qui s'incrémente à chaque fois qu'on crée un objet voiture:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
class Voiture: nombre_de_voitures = 0 # variable de classe def __init__(self, marque): self.marque = marque Voiture.nombre_de_voitures += 1 def show_marque(self): print(f"La marque de la voiture est : {self.marque}.") @classmethod def nombre_total(cls): print(f"Il y a {cls.nombre_de_voitures} voitures dans le parking.") voiture1 = Voiture("Renault") voiture2 = Voiture("Dacia") voiture3 = Voiture("Mercedes") voiture1.show_marque() voiture2.show_marque() voiture3.show_marque() # accès à la méthode de classe Voiture.nombre_total() print("Accès à la méthode de classe via un objet d'instance : ") voiture1.nombre_total() """ output: La marque de la voiture est : Renault. La marque de la voiture est : Dacia. La marque de la voiture est : Mercedes. Il y a 3 voitures dans le parking. Accès à la méthode de classe via un objet d'instance : Il y a 3 voitures dans le parking. """ |
7. Les méthodes statiques
Une méthode statique (static method) est une méthode de classe ayant la propriété d'être exécutée sans passer par l'instanciation.
Exemple (méthode statique)
|
1 2 3 4 5 6 7 8 9 |
class myClass: def __init__(self): pass # création d'une méthode statique @staticmethod def myStaticMethod(): print("Voici un exmple de méthode statique en Python") myClass.myStaticMethod() |
8. Héritage en Python
Pour éviter de recopier le code d'une classe, on utilise la méthode d'héritage. La méthode d'héritage consiste à créer à partir d'une classe mère une autre classe appelé classe fille qui hérite toutes les méthodes et propriétés de la classe mère. Pour simplifier l'acquisition pour les apprenants débutant, nous allons traiter ce concept sur un exemple simple :
Classe mère:
|
1 2 3 4 |
class Personne: def __init__(self,nom,age): self.nom = nom self.age=age |
Nous venons de définir une classe Personne dont les attributs sont nom et age. Nous allons maintenant créer une classe fille nommée Student qui hérite les mêmes méthodes et propriétés de la classes mère Personne. La syntaxe générale de l'héritage se fait grâce à la commande:
|
1 |
class classe_fille(classe_mère) |
Qui veut dire que la classe classe_fille hérite de la calsse classe_mère.
Pour notre cas de la classe fille Student hérite de la classe mère Personne.
Exemple ( Student hérite de la classe Personne)
|
1 |
class Student(Personne): |
L'héritage des attributs nom et age se fait via la commande:
|
1 |
Personne.__init__(self,nom,age) |
Code de la classe fille Student:
|
1 2 3 4 5 6 7 |
class Student(Personne): # définition des attributs des attributs def __init__(self,nom,age,filiere): # héritage des attributs depuis la classe mère Personne Personne.__init__(self,nom,age) # ajout d'un nouvel attribut filiere à la classe fille self.filiere = filiere |
Exemple complet
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
class Personne: def __init__(self,nom,age): self.nom = nom self.age=age # La classe fille Student hérite de la classe mère Personne class Student(Personne): # définition des attributs des attributs def __init__(self,nom,age,filiere): # héritage des attributs depuis la classe mère Personne Personne.__init__(self,nom,age) # ajout d'un nouvel attribut filiere à la classe fille self.filiere = filiere Stud = Student("Albert",27,"math") print("Le nom de l'étudiant est : " ,Stud.nom) print("L'age de l'étudiant est : " ,Stud.age) print("La filière de l'étudiant est : " ,Stud.filiere) """ Ce qui affiche après exécution: Le nom de l'étudiant est : Albert L'age de l'étudiant est : 27 La filière de l'étudiant est : math """ |
9. Héritage multiple
En programmation orientée objet, on parle d'héritage multiple, lorsqu'une classe hérite de deux ou plusieurs classes.
Exemple (héritage multiple)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
class Calcul1: def Somme(self,a,b): return a + b class Calcul2: def Multiplication(self,a,b): return a*b # heritage multiple class Calcul3(Calcul1,Calcul2): def division(self,a,b): return a/b Calcul = Calcul3() print(Calcul.Somme(7 , 5)) # affiche 12 print(Calcul.Multiplication(10 , 5)) # affiche 50 print(Calcul.division(8 , 3)) # affiche 2.666666 |
Pour plus de détails sur l'héritage multiple, voir notre article détaillé : Héritage multiple
10. Surcharge de méthodes (overloading)
La surcharge en programmation orientée objet est méthode permettant de définir plusieurs fois une même méthode avec des arguments différents. Le compilateur choisit la méthode qui doit être appelée en fonction du nombre et du type des arguments .
Contrairement aux autres langages objet Java, C++, python ne prend pas en charge la surcharge de méthode par défaut. Mais il existe différentes façons d'obtenir une surcharge de méthode en Python.
Le problème avec la surcharge de méthodes en Python est que nous pouvons surcharger les méthodes mais ne pouvons utiliser que la dernière méthode définie.
Exemple (surcherge de méthodes)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Calcul: def __init__(self): pass def somme(self , x , y): return x + y def somme(self ,a , b , c): return a + b + c C = Calcul() print("La somme est 2 + 3 + 4 = " , C.somme(2 , 3 , 4)) # affiche: La somme est 2 + 3 + 4 = 9 |
Par contre si on n'execute pas la dernières méthode:
Exemple( erreur)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
def __init__(self): pass def somme(self , x , y): return x + y def somme(self ,a , b , c): return a + b + c C = Calcul() print("La somme est 2 + 3 = " , C.somme(2 , 3 )) #L'interpréteur de Python indique l'erreur suivante: #Calcul.somme() missing 1 required positional argument: 'c' |
Remarque
L'opération C.somme(2 , 3) ne peut être exécuté! Néanmoins, il y a une possibilité de faire fonctionner correctement la surcharge de méthodes en Python via le module multipledispatch qu'on peut installer facilement via l'utilitaire pip:
|
1 |
pip install multipledispatch |
Exemple (Surcharge de méthodes via multipledispatch)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
class Calcul: def __init__(self): pass @dispatch(int,int) def somme(self , x , y): return x + y @dispatch(int,int,int) def somme(self ,a , b , c): return a + b + c @dispatch(float, float) def somme(self ,a , b): return a + b C = Calcul() print("La somme de 2 et 3 est : " , C.somme(2 , 3)) print("La somme de 2.5 et 3.2 est : " , C.somme(2.5 , 3.2)) print("La somme de 2 , 3 et 4 est : " , C.somme(2 , 3 , 4)) """ Affiche à la sortie: La somme de 2 et 3 est : 5 La somme de 2.5 et 3.2 est : 5.7 La somme de 2 , 3 et 4 est : 9 """ |
11. Polymorphisme et redéfinition de méthodes (overriding methods)
Linguistiquement, le mot polymorphisme signifie plusieurs formes. En Python, le polymorphisme sert à définir une méthodes dans la classe enfant avec le même nom qu'une méthodes de la classe mère. Le principe de l'héritage polymorphe est d'offrir la possibilité à une classe enfant d'hériter une méthode de la classe mère avec modification selon le besoin de la classe enfant. Exemple pour une classe Personne on peut définir une méthode afficher() qui affiche les attributs d'un objet : nom, prénom, age... et dans une autre classe Student qui hérite de la classe Personne on aura besoin de la même méthode afficher() mais cette fois elle affiche des informations supplémentaires spécifique à la classe enfant comme section, niveau d'études...
Exemple (redéfinition de méthodes)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
class Personne: def __init__(self, name , age): self.name = name self.age = age def afficher(self): print("le nom est : " , self.name , " l'age est : " , self.age) # Heritage de la classe parent class Student(Personne): def __init__(self , name , age , section): Personne.__init__(self , name , age) self.section = section # modification de la methode afficher def afficher(self): print("le nom est : " , self.name , " l'age est : " , self.age, "la section de l'etudiant est : " , self.section) Stud = Student("Majid" , 23 , "informatique") print(Stud.afficher()) # la sortie est : e nom est : Majid l'age est : 23 la section de l'etudiant est : informatique |
12. Les classes abstraites en Python
Les classes abstraites sont des classes qui contiennent une ou plusieurs méthodes abstraites. Une méthode abstraite est une méthode déclarée, mais qui ne contient aucune implémentation. Les classes abstraites ne peuvent pas être instanciées et nécessitent des sous-classes pour fournir des implémentations pour les méthodes abstraites. afin de pouvoir utiliser les classes abstraites, il faut au préalable importer la classe ABC depuis le module abc:
|
1 |
from abc import ABC , abstractmethod |
Exemple (classe abstraite)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
from abc import ABC , abstractmethod # define abstract class class Polygon(ABC): # define abstract method @abstractmethod def sidesNumber(self): pass class Triangle(Polygon): def sidesNumber(self): print("Un triangle admet 3 cotes") class Rectangle(Polygon): def sidesNumber(self): print("Un rectangle admet 4 cotes") # Instanciation T = Triangle() T.sidesNumber()# affiche: Un triangle admet 3 cotes R = Rectangle() R.sidesNumber() # affiche: Un rectangle admet 4 cotes |
13. Les interfaces en Python
Une interface est un type de référence regroupant une collection de méthodes abstraites tout en exigeant un certain nombre de règles:
- Une interface établit un contrat entre une classe et l'interface qu'elle implémente.
- Une interface ne contient que des prototypes de méthodes non-implémentées.
- La classe qui implémente l'interface doit fournir une implémentation pour chacune des méthodes de l'interface.
- En générale on parle d'implémenter une interface (et non hériter d'une interface), mais en Python il s'agit d'un type d'héritage.
Python est doté d'une bibliothèque nommée interface permettant de déclarer des interfaces et pour affirmer statiquement que les classes implémentent ces interfaces. Il fournit une sémantique plus stricte que le module abc intégré de Python et vise à produire des messages d'erreur d'une utilité exceptionnelle lorsque les interfaces ne sont pas satisfaites.
Afin de pouvoir utiliser les interfaces en Python, il faut installer le module interface via l'utilitaire pip:
|
1 |
pip install interface |
Exemple ( interfaces en python)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from interface import implements, Interface class MyInterface(Interface): def somme(self, x , y): pass class MyClass(implements(MyInterface)): def somme(self, x , y): return x + y My = MyClass() print(My.somme(3, 5)) # affiche 8 |
Pour plus de détails sur les interfaces Python veuillez consulter la documentation officielle: https://interface.readthedocs.io/en/latest/
Younes Derfoufi
CRMEF OUJDA
1 thought on “La Programmation Orientée 0bjet POO En Python”