Cours de Python - Programmation

Orientée Objet
Dr Nafi Dione
25 mars 2025

Table des matières

1 Introduction 3
1.1 Qu’est-ce que la Programmation Orientée Objet (POO) ? . . . 3

2 Les fondamentaux de la POO en Python 3

2.1 Classes et objets . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Type classe en Python . . . . . . . . . . . . . . . . . . . . . . 3
2.2.1 Classes Simples (Classes Normales . . . . . . . . . . . . 3
2.2.2 Classes avec Héritage . . . . . . . . . . . . . . . . . . . 4
2.2.3 Classes Statiques (Sans Instance) . . . . . . . . . . . . 4
2.2.4 Classes Abstraites . . . . . . . . . . . . . . . . . . . . . 4
2.2.5 Utilisation de classes abstraites . . . . . . . . . . . . . 5
2.3 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Notion d’attributs en Python . . . . . . . . . . . . . . . . . . 7
2.4.1 Attributs d’instance . . . . . . . . . . . . . . . . . . . 7
2.4.2 Attributs de classe . . . . . . . . . . . . . . . . . . . . 8
2.4.3 Attributs statiques . . . . . . . . . . . . . . . . . . . . 8
2.4.4 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Constructeur et héritage 10

4 Héritage multiple 11

1
5 Surcharge de Méthodes en Python 12
5.1 Surcharge avec des Arguments par Défaut . . . . . . . . . . . 12
5.2 Surcharge avec *args et **kwargs . . . . . . . . . . . . . . . 12
5.3 Surcharge en Fonction du Type d’Argument . . . . . . . . . . 12
5.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.4 Polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.5 Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . 13

2
 1 Introduction
1.1 Qu’est-ce que la Programmation Orientée Objet
(POO) ?
La Programmation Orientée Objet (POO) est un paradigme de program-
mation qui repose sur le concept d’objets. Un objet est une entité qui com-
bine :
— Des données (attributs/propriétés)
— Des fonctions (méthodes) qui interagissent avec ces données
La POO est utilisée pour organiser le code en modules réutilisables et
mieux structurés.
Voici quelques avantages de la POO :
— Réutilisation du code grâce à l’héritage
— Encapsulation : regroupe les données et les méthodes associées
— Modularité : facilite la gestion et la maintenance du code
— Polymorphisme : permet d’utiliser le même nom de méthode pour des
comportements différents

2 Les fondamentaux de la POO en Python

2.1 Classes et objets
Une classe est un modèle qui définit les attributs (données) et les méthodes
(fonctions) que posséderont ses objets.
Un objet est une instance d’une classe, c’est-à-dire un élément concret créé
à partir de ce modèle.

2.2 Type classe en Python

On utilise le mot-clé class pour créer une classe.

2.2.1 Classes Simples (Classes Normales

1 class nomClasse :
2 -- atrributs
3 -- methodes

3
 2.2.2 Classes avec Héritage
L’héritage permet à une classe d’hériter des attributs et méthodes d’une
autre classe.
1 class Mere :
2 -- attribut1
3 class Fille ( Mere ) :
4 -- attribut1
5 -- attribut2
6 ...

2.2.3 Classes Statiques (Sans Instance)

Une classe statique ne dépend pas d’instances et n’a que des méthodes
statiques.
1 \ begin { lstlisting }
2 class Utilitaire :
3 @staticmethod
4 def c o n v e r t i r _ k m _ e n _ m i l e s ( km ) :
5 return km * 0.621371
6

7 print ( Utilitaire . c o n v e r t i r _ k m _ e n _ m i l e s (10) )

2.2.4 Classes Abstraites

Une classe abstraite ne peut pas être instanciée directement. Elle sert de
modèle aux classes filles.
1 from abc import ABC , abstractmethod
2

3 class A ( ABC ) : # ABC signifie " Abstract Base Class "

4 @abstractmethod
5 def med_one ( self ) :
6 pass # M t h o d e d f i n i r dans les classes
filles
7

8 class B ( Forme ) :
9 def med_one ( self ) :
10 # implementation
Exemple : Dans les cas des véhicules, on peut considérer les classes Véhicule
, VéhiculeTerrestre et VéhiculeAérien comme abstraites,
les classes Voiture , Moto , Avion , Camion , Hydravion comme concrètes.

4
 En effet, on ne veut pas vraiment construire un VéhiculeTerrestre , ce serait
trop abstrait.
On veut plutôt construire un Camion ou une Voiture . VéhiculeTerrestre va
être utilisée pour définir les attributs et les méthodes que devront contenir
toutes les classes filles.
Une classe abstraite est constituée de méthodes et potentiellement d’attri-
buts.

— Des méthodes possèdant une implémentation, qui peut être utilisée ou

redéfinie dans les classes filles (c’est ce qu’on a fait jusqu’à présent).
— Des méthodes simplement déclarées nom et signature et ne possèdant
aucune implémentation . Ces méthodes devront obligatoirement être
implémentées dans les classes filles.
— Certaines méthodes peuvent avoir une implémentation mais être marquées
comme abstraites, et doivent donc être implémentées par les classes
filles.
NB :Les méthodes sans implémentation ou marquées abstraites s’ap-
pellent des méthodes abstraites ou méthodes virtuelles.

2.2.5 Utilisation de classes abstraites

1 class Vehicu leTerr estre ( abc . ABC ) :

2

3 def __init__ ( self , nb_roues ) :

4 self . vitesse = 0
5 self . est_allume = False
6 self . nb_roues = nb_roues
7 self . bon_etat_roues = True
8

9 def get_vitesse ( self ) :

10 pass
11

12 @abc . abstractmethod
13 def co nt ro le _te ch ni qu e ( self ) :
14 pass
15

16 @abc . abstractmethod
17 def demarrer ( self ) :
18 self . est_allume = True
Que donne v = VehiculeTerrestre() ?

5
 1 class Voiture ( Vehic uleTer restre ) :
2 def __init__ ( self , marque ) :
3 super () . __init__ (4)
4 self . marque = marque
5

6 def co nt ro le _te ch ni qu e ( self ) :

7 self . bon_etat_roues = True
8

9 def demarrer ( self ) :

10 super () . demarrer ()
Que donne v = Voiture(”Audi”) ?

1 class Voiture ( Vehic uleTer restre ) :

2 def __init__ ( self , marque ) :
3 super () . __init__ (4)
4 self . marque = marque
5

6 def demarrer ( self ) :

7 super () . demarrer ()
Que donne v = Voiture(”Audi”) ?

Règles :
— En Python, une méthode abstraite doit être obligatoirement de visibi-
lité publique ou protégée, afin que les classes filles puissent en hériter.
— Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir
toutes les méthodes abstraites. Cependant, si tel est le cas, elle devient
elle-même abstraite et ne peut être instanciée.
En gros, une classe concrète doit re-définir toutes les méthodes abs-
traites.

2.3 Interfaces
Une interface est une déclaration de comportements que doit posséder les
classes l’implémentant.
En Python (contrairement au Java par exemple), on passe par les classes
abstraites pour définir une interface.
Pour définir ce qui ressemble le plus à une interface, on va déclarer une classe
abstraite respectant les règles suivantes :
— aucun constructeur ne sera défini ou implémenté ;
— toutes les méthodes définies seront abstraites ;

6
 — aucune des méthodes définies ne possédera une implémentation par
défaut.
1 class Vehicu leTerr estre ( abc . ABC ) :
2 @abc . abstractmethod
3 def accelerer ( self ) :
4 pass
5

6 @abc . abstractmethod
7 def freiner ( self ) :
8 pass
9

10 class Voiture ( Vehic uleTer restre ) :

11 def accelerer ( self ) :
12 print ( " fast " )
13 def freiner ( self ) :
14 print ( " slow " )
15

16 class Moto ( Vehicu leTer restre ) :

17 def accelerer ( self ) :
18 print ( " vast " )
19 def freiner ( self ) :
20 print ( " vslow " )

2.4 Notion d’attributs en Python

En Python, on distingue plusieurs types d’attributs dans une classe :
— Attributs d’instance
— Attributs de classe
— Attributs statiques
— Constantes

2.4.1 Attributs d’instance

Ce sont les attributs propres à chaque instance de la classe.
Définis dans init avec self.
1 class Voiture :
2 def __init__ ( self , marque , couleur ) :
3 self . marque = marque # Attribut d ’ instance
4 self . couleur = couleur # Attribut d ’ instance

7
 2.4.2 Attributs de classe
Partagés par toutes les instances.
Définis directement dans la classe (en dehors de init ).
1 class Voiture :
2 nb_roues = 4 # Attribut de classe
Tous les objets partagent nb roues.

2.4.3 Attributs statiques

Similaires aux attributs de classe, mais ils ne sont pas liés aux instances.
Utilisent @staticmethod pour des méthodes.
On les déclare dans la classe, mais sans self.
1 class Voiture :
2 nb_roues = 4 # Attribut de classe
3

4 @staticmethod
5 def info () :
6 return " Infos . "
7

8 print ( Voiture . info () ) # Fonctionne sans instance

Tous les objets partagent nb roues.

2.4.4 Constantes
Pas de mot-clé const en Python.
Convention : les constantes sont en majuscules.
Généralement définies comme attributs de classe.

1 class Config :
2 PI = 3.14159 # Constante
3 MOIS = " Ramadan "
4

5 print ( Config . PI ) # 3.14159

Bonne pratique : Ne pas modifier ces valeurs, mais Python ne les empêche pas.

2.5 Encapsulation
L’encapsulation est un concept fondamental de la programmation orientée
objet (POO). Elle consiste à protéger les données et à restreindre l’accès aux

8
 Type Définition Modifiable par self ?
Attribut d’instance Défini dans init avec Oui
self
Attribut de classe Défini directement dans la Oui
classe et accessible via self
Oui
Attribut statique Défini dans la classe sans Non
self, souvent utilisé pour
des constantes
Constante Attribut de classe écrit Possible mais déconseillé
en majuscules (convention)
pour indiquer qu’il ne doit
pas être modifié

Table 1 – Résumé des types d’attributs en Python

attributs et méthodes d’une classe pour éviter toute modification accidentelle.

1 class A :
2 def __init__ ( self , param1 , param2 , param3 ) :
3 self . param1 = param1 # Public
4 self . _param2 = param2 # Protege
5 self . __param3 = param3 # prive
Pourquoi utiliser l’encapsulation ?
— Protéger les données sensibles ;
— Empêcher la modification accidentelle ;
— Encapsuler la logique ;
Accesseurs (getters) et mutateurs (setters)
Comme les attributs privés sont inaccessibles directement, on utilise des
méthodes getters et setters pour les lire ou les modifier.

1 class A :
2 def __init__ ( self , param1 ) :
3 self . __param1 = param1 # prive
4

5 @property
6 def param1 ( self ) :
7 """ Getter : permet de lire l ’ attribut prive .
"""

9
 8 return self . __param1
9 @param1 . setter
10 def param1 ( self , new_param ) :
11 self . __param1 = new_param

2.6 Héritage
L’héritage en Python est un concept fondamental de la programmation
orientée objet (POO) qui permet à une classe d’hériter des attributs et des
méthodes d’une autre classe. Cela favorise la réutilisation du code et rend les
programmes plus modulaires.

2.6.1
Concept de base L’héritage permet de créer une nouvelle classe (classe
dérivée ou sous-classe) à partir d’une classe existante (classe de base ou super-
classe). La sous-classe hérite de tous les attributs et méthodes de la super-
classe, mais peut également ajouter ses propres fonctionnalités ou redéfinir
des méthodes existantes.

2.6.2
Syntaxe de l’héritage
1 class Animal :
2 def parler ( self ) :
3 print ( " L ’ animal fait du bruit " )
4

5 class Chien ( Animal ) : # Chien h r i t e de Animal

6 def parler ( self ) : # R e d f i n i t i o n de la m t h o d e
7 print ( " Le chien aboie " )
8

9 mon_chien = Chien ()
10 mon_chien . parler () # Affiche : Le chien aboie

3 Constructeur et héritage
Si la sous-classe a un constructeur ( init ), elle doit appeler explicite-
ment le constructeur de la super-classe pour hériter des attributs :
1 class Animal :
2 def __init__ ( self , nom ) :

10
 3 self . nom = nom
4 class Chat ( Animal ) :
5 def __init__ ( self , nom , couleur ) :
6 super () . __init__ ( nom )
7 self . couleur = couleur
8 mon_chat = Chat ( " Mimi " , " blanche " )
9 mon_chat . parler () # Affiche : Mimi miaule et est de
couleur blanche

4 Héritage multiple
Python prend en charge l’héritage multiple, ce qui signifie qu’une classe
peut hériter de plusieurs super-classes :
1 class Canin :
2 def aboyer ( self ) :
3 print ( " Aboiement " )
4

5 class Felin :
6 def miauler ( self ) :
7 print ( " Miaulement " )
8

9 class Chimere ( Canin , Felin ) :

10 pass
11

12 monstre = Chimere ()
13 monstre . aboyer () # Affiche : Aboiement
14 monstre . miauler () # Affiche : Miaulement
La fonction super() permet d’accéder aux méthodes de la super-classe
sans avoir besoin de la nommer explicitement.
En Python, lorsqu’une classe hérite de plusieurs classes (héritage multiple), la
fonction super() suit l’ordre de résolution des méthodes appelé MRO (Method
Resolution Order).
1 class Personne :
2 def marcher ( self ) :
3 print ( " La personne marche " )
4

5 class Employe ( Personne ) :

6 def marcher ( self ) :
7 super () . marcher ()
8 print ( " L ’ e m p l o y marche vers son bureau " )

11
 9

10 employe = Employe ()
11 employe . marcher ()

5 Surcharge de Méthodes en Python

En Python, la surcharge de méthodes n’est pas nativement supportée,
mais elle peut être simulée de plusieurs manières. Voici quelques exemples de
techniques permettant de simuler la surcharge.

5.1 Surcharge avec des Arguments par Défaut

1 class Calculatrice :
2 def additionner ( self , a , b =0) :
3 return a + b
4

5 calc = Calculatrice ()
6 print ( calc . additionner (5) ) # 5
7 print ( calc . additionner (5 , 10) ) # 15
Listing 1 – Surcharge avec arguments par défaut

5.2 Surcharge avec *args et **kwargs

1 class Addition :
2 def ajouter ( self , * args ) :
3 return sum ( args )
4

5 add = Addition ()
6 print ( add . ajouter (1 , 2) ) # 3
7 print ( add . ajouter (1 , 2 , 3 , 4) ) # 10
Listing 2 – Surcharge avec *args et **kwargs

5.3 Surcharge en Fonction du Type d’Argument

1 class Forme :
2 def area ( self , * args ) :
3 if len ( args ) == 1:
4 return 3.14 * args [0]**2

12
 5 elif len ( args ) == 2:
6 return args [0] * args [1]
7 else :
8 return " Nombre d ’ arguments invalide "
9

10 forme = Forme ()
11 print ( forme . area (5) ) # Aire d ’ un cercle avec
rayon 5
12 print ( forme . area (5 , 10) ) # Aire d ’ un rectangle 5 x10
Listing 3 – Surcharge en fonction du type d’argument

5.3.1
Bonnes pratiques
— Utiliser super() pour garantir la compatibilité avec l’héritage mul-
tiple.
— Ne pas abuser de l’héritage : utiliser la composition si cela est plus
approprié.
— Redéfinir proprement les méthodes pour éviter des comportements
inattendus.

5.4 Polymorphisme
5.5 Gestion des erreurs

13