Introduction à la Programmation Orientée Objet(POO) en Python

Contenu

1. Introduction ................................................................................................................................... 2
1. La classe :........................................................................................................................................ 3
2. Le constructeur .............................................................................................................................. 3
3. Le destructeur ................................................................................................................................ 4
4. Un objet .......................................................................................................................................... 5
5. Les attributs .................................................................................................................................... 5
6. Les méthodes ................................................................................................................................. 6
7. L’abstraction ................................................................................................................................... 8
8. Encapsulation ............................................................................................................................... 10
9. Les Getters(Accesseurs)................................................................................................................ 12
10. Les Setters(Mutateurs) ............................................................................................................. 13
11. Applications .............................................................................................................................. 15
12. Héritage .................................................................................................................................... 16
13. Le polymorphisme .................................................................................................................... 17
14. La surcharge ............................................................................................................................. 19
15. Interface et classe abstraite ..................................................................................................... 20
16. Implémentation ........................................................................................................................ 24

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 1
 Introduction à la Programmation Orientée Objet(POO) en Python

1. Introduction

La Programmation Orientée Objet (POO) est un paradigme de programmation qui

permet d'organiser et de structurer efficacement du code en utilisant des concepts
tels que les classes, les objets, les constructeurs, les destructeurs, les propriétés, les
méthodes, l'encapsulation, les Getters, les Setters, l'héritage, l’abstraction, la
surcharge, le polymorphisme, l’interface et l’implémentation.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 2
 Introduction à la Programmation Orientée Objet(POO) en Python

1. La classe :

La POO repose principalement sur les classes. Une classe est une structure de
données qui définit à la fois des attributs (variables membres) et des méthodes
(fonctions membres). Elle est un modèle ou un plan qui définit les caractéristiques
et les comportements d'un type d'objet.

class Livre:
def __init__(self):
pass

2. Le constructeur

Un constructeur est une méthode spéciale qui est utilisée pour initialiser les objets
d'une classe. Il est appelé automatiquement lors de la création d'un nouvel objet et
est responsable de l'allocation de mémoire, de l'initialisation des attributs et de
l'exécution de toute autre logique nécessaire pour configurer l'objet.

un constructeur est défini dans une classe avec le même nom __init__(self). Il n'a pas
de type de retour spécifié. Il peut prendre des paramètres ou être défini sans
paramètre, ce qui est appelé constructeur par défaut.

Voici quelques points importants à retenir sur les constructeurs :

 Nom : Un constructeur est une fonction appelée __init__(self). Il peut prendre

un ou plusieurs paramètres.

 Appel automatique : Lorsque vous créez un nouvel objet à partir d'une classe,
le constructeur approprié est appelé automatiquement pour initialiser l'objet.

 Initialisation des attributs : Un constructeur est utilisé pour initialiser les

attributs de la classe avec des valeurs spécifiques. Cela peut inclure l'allocation
de mémoire, l'affectation de valeurs par défaut ou l'initialisation avec des
valeurs fournies en paramètres.
 Constructeur par défaut : Si aucun constructeur n'est défini explicitement dans
la classe, l'interpréteur génère un constructeur par défaut automatiquement.

 Surcharge de constructeur : Il est possible de définir plusieurs constructeurs

dans une classe, chacun ayant une liste de paramètres différente. Cela permet
de créer des objets avec différentes configurations en fonction des arguments
passés lors de leur création.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 3
 Introduction à la Programmation Orientée Objet(POO) en Python

class Livre:
def __init__(self):
pass

3. Le destructeur

Un destructeur est une méthode spéciale dans la programmation orientée objet

(POO) qui est appelée lorsqu'un objet est détruit ou va sortir de portée. Son rôle
principal est de libérer les ressources allouées par l'objet avant sa destruction, ce qui
permet de prévenir les fuites de mémoire et de gérer proprement les ressources
utilisées par l'objet.

Le destructeur est défini dans une classe en utilisant la méthode __del__(self):

 Appel automatique : Le destructeur est appelé automatiquement lorsque

l'objet est détruit. Cela se produit lorsque l'objet sort de portée (par exemple, à
la fin d'une fonction où l'objet a été déclaré localement).

 Libération des ressources : Le destructeur est utilisé pour libérer les ressources
allouées par l'objet, telles que la mémoire allouée dynamiquement, les fichiers
ouverts, les connexions réseau, etc. Il est important de libérer toutes les
ressources pour éviter les fuites de mémoire et les comportements
indésirables.

 Appel récursif : Les destructeurs sont appelés dans l'ordre inverse de la

création des objets. Cela signifie que si un objet A contient un autre objet B en
tant que membre, le destructeur de B sera appelé avant le destructeur de A.
Cela permet de libérer les ressources dans l'ordre approprié, en évitant les
dépendances inverses.

class Livre:
def __init__(self):
pass

def __del__(self):
print(self, " est surimé")
L1 = Livre()
L2 = Livre()
L3 = Livre()
print(L1)
print(L2)
print(L3)
L1=None

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 4
 Introduction à la Programmation Orientée Objet(POO) en Python

4. Un objet

Un Objet est une instance spécifique d'une classe en programmation. Lorsqu'une

classe est instanciée, c'est-à-dire qu'un nouvel objet est créé, cet objet possède ses
propres attributs (variables) et méthodes (fonctions) basés sur la définition de la
classe.
Un objet peut être considéré comme une entité autonome qui a un état (représenté
par ses attributs) et peut effectuer des actions (représentées par ses méthodes).
Par exemple, si nous avons une classe "Voiture", un objet spécifique pourrait être
"Voiture A" avec son propre état (par exemple, la couleur, la marque, le modèle) et
ses propres actions possibles (par exemple, accélérer, freiner, klaxonner).
Les objets sont utilisés pour modéliser des entités du monde réel ou des concepts
abstraits dans le domaine d'application du programme. Ils permettent d'organiser et
de structurer le code en encapsulant les données et les fonctionnalités connexes dans
des unités autonomes. Les objets interagissent entre eux en envoyant des messages
et en collaborant pour réaliser des tâches plus complexes.

class Livre:
def __init__(self):
pass

L1 = Livre()
L2 = Livre()
L3 = Livre()

print(L1)
print(L2)
print(L3)

5. Les attributs

Les attributs, également appelés données membres ou variables membres, sont des
variables déclarées à l'intérieur d'une classe. Ils représentent les caractéristiques ou
les données associées à un objet de cette classe. Chaque instance de la classe a sa
propre copie des attributs, qui stockent des valeurs spécifiques pour chaque objet.

Les attributs permettent de décrire l'état d'un objet et d'enregistrer les données qui
lui sont associées. Par exemple, dans une classe ‘Personne’, les attributs pourraient
inclure le nom, prénom, le salaire, l'âge, l'adresse, etc. Chaque objet ‘Personne’ aurait
ses propres valeurs pour ces attributs.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 5
 Introduction à la Programmation Orientée Objet(POO) en Python

a. Type : Chaque attribut a un type de données qui spécifie le genre de valeur

qu'il peut stocker. Cela peut être un type primitif (par exemple, int, float, str,
bool) ou un type personnalisé (par exemple, une autre classe).

b. Initialisation : Les attributs peuvent être initialisés dans le constructeur de la

classe ou lors de leur déclaration. La valeur initiale peut être spécifiée de
manière explicite ou par défaut.

c. Accès : Les attributs peuvent être accédés et modifiés à l'intérieur de la classe

par ses méthodes membres. En dehors de la classe, l'accès aux attributs
dépend de leur niveau de visibilité (privé, public) et des mécanismes d'accès
fournis par la classe (par exemple, les méthodes getters et setters).

d. Notation : Les attributs sont généralement référencés à l'intérieur de la classe

en utilisant le mot-clé self (par exemple, [Link]). À l'extérieur de la classe, les
attributs sont accessibles en utilisant l'opérateur de point ([Link]).

class Livre:
def __init__(self, titre, quantite, auteur, prix):
[Link] = titre
[Link] = quantite
[Link] = auteur
[Link] = prix

L1 = Livre('Python', 12, 'MATY', 3000)

L2 = Livre('Java', 18, 'Guifo', 2200)
L3 = Livre('Reseau', 28, 'Savage', 3200)

print(L1)
print(L2)
print(L3)

6. Les méthodes

Les méthodes, également appelées fonctions membres, sont des fonctions définies
à l'intérieur d'une classe. Elles permettent de définir le comportement et les actions
associées à un objet de cette classe. Les méthodes sont utilisées pour effectuer des

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 6
 Introduction à la Programmation Orientée Objet(POO) en Python

opérations sur les attributs d'un objet, interagir avec d'autres objets, effectuer des
calculs, fournir des fonctionnalités spécifiques, etc.

Les caractéristiques importantes des méthodes :

a. Déclaration et définition : Les méthodes sont déclarées à l'intérieur de la

définition de la classe et peuvent être définies à l'intérieur ou à l'extérieur de la
classe, selon la convention de définition choisie.
b. Accessibilité : Les méthodes peuvent être déclarées avec différents niveaux
d'accessibilité, tels que privé, protégé ou public, pour contrôler leur visibilité et
leur accessibilité à d'autres parties du code.
c. Signature : Chaque méthode a une signature unique qui spécifie son nom, son
type de retour, ses paramètres.

d. Accès aux attributs : Les méthodes ont accès aux attributs de la classe et
peuvent les lire, les modifier ou les manipuler selon les besoins. Cela permet
d'encapsuler la logique de traitement des données à l'intérieur de la classe.
e. Invocation : Les méthodes sont invoquées sur des objets spécifiques à l'aide de
l'opérateur de point (‘[Link]()’)
f. Passage de paramètres : Les méthodes peuvent accepter des paramètres, qui
sont des valeurs passées à la méthode pour effectuer des opérations ou des
calculs spécifiques. Les paramètres peuvent être passés par valeur, par
référence ou par pointeur.

g. Retour de valeurs : Les méthodes peuvent retourner une valeur en utilisant un

type de retour spécifié. La valeur de retour peut être utilisée pour obtenir un
résultat calculé par la méthode ou pour transmettre une information à
l'appelant.

h. Surcharge de méthode : Il est possible de définir plusieurs méthodes avec le

même nom dans une classe, mais avec des signatures différentes. Cela permet
d'effectuer des opérations similaires sur différents types de données ou de
fournir des fonctionnalités différentes en fonction des paramètres passés.

i. Méthodes statiques : Les méthodes statiques sont des méthodes qui

n'appartiennent pas à une instance spécifique de la classe, mais à la classe
elle-même. Elles peuvent être invoquées directement à partir de la classe, sans
avoir besoin d'une instance de cette classe. Et doivent avoir la mention
@staticmethod

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 7
 Introduction à la Programmation Orientée Objet(POO) en Python

class Personne:
Nom="MATY"
Prenom="Maman"
Age=53
Salaire=1500000
Taille= 1.89

def afficher(self):
print([Link],[Link], [Link],[Link], [Link])

P=Personne()
[Link]()

7. L’abstraction

L'abstraction est un concept clé en programmation orientée objet (POO) qui vise à
simplifier la complexité en masquant les détails internes d'un objet ou d'un système
et en se concentrant uniquement sur les aspects essentiels et pertinents.

L'abstraction permet de représenter un objet, un concept ou un système de manière

simplifiée, en identifiant les caractéristiques et les fonctionnalités importantes et en
ignorant les détails de mise en œuvre. Elle fournit une vue d'ensemble cohérente et
concise qui facilite la compréhension et l'utilisation de l'objet ou du système.

Voici quelques points importants sur l'abstraction :

a. Généralisation : L'abstraction consiste à identifier les caractéristiques

communes et les comportements généraux d'un ensemble d'objets ou de
systèmes, et à les regrouper dans une représentation abstraite commune. Cela
permet de créer des classes abstraites ou des interfaces qui définissent ces
caractéristiques communes.
b. Masquage des détails : L'abstraction masque les détails internes d'un objet ou
d'un système, de sorte que les utilisateurs ou les développeurs n'ont pas
besoin de connaître les détails de mise en œuvre pour utiliser ou interagir avec
l'objet ou le système. Ils n'ont accès qu'aux fonctionnalités et aux interfaces
abstraites.
c. Niveau de détail : L'abstraction permet de spécifier le niveau de détail souhaité
en fonction du contexte d'utilisation. Par exemple, une classe abstraite peut
définir des méthodes abstraites qui décrivent le comportement général, tandis
que les classes dérivées fournissent des implémentations spécifiques avec plus
de détails.
d. Favorise la modularité et la réutilisabilité : L'abstraction facilite la création de
modules indépendants et réutilisables. En se concentrant sur les

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 8
 Introduction à la Programmation Orientée Objet(POO) en Python

caractéristiques essentielles et en masquant les détails de mise en œuvre, il

devient plus facile de créer des objets et des systèmes modulaires qui peuvent
être combinés et réutilisés dans différentes applications.

L'abstraction permet d'apporter une meilleure compréhension, une plus grande

flexibilité et une réduction de la complexité dans la conception et le développement
de logiciels. Elle facilite la gestion de la complexité en fournissant une vue d'ensemble
simplifiée et en se concentrant sur les aspects importants, ce qui permet une
meilleure organisation, une meilleure maintenance et une meilleure évolutivité des
systèmes logiciels.

Exemples complets

La classe Livre

class Livre:

def __init__(self, titre, quantite, auteur, prix):

[Link] = titre
[Link] = quantite
[Link] = auteur
[Link] = prix

def __del__(self):
print(f"{[Link]} est supprimé aumatiquement")

def __repr__(self):
return f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix: {[Link]}"

def detail(self):
print(f"\n-----------\nLivre: {[Link]}, \nQuantité: {[Link]}, \nAuteur: {[Link]}, \nPrix:
{[Link]}")

L1 = Livre('Python', 12, 'MATY', 3000)

L2 = Livre('Java', 18, 'Guifo', 2200)
L3 = Livre('Reseau', 28, 'Savage', 3200)

print(L1)
print(L2)
print(L3)
[Link]()
# L3=None

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 9
 Introduction à la Programmation Orientée Objet(POO) en Python
La Classe Personne

class Personne:
Nom="MATY"
Prenom="Maman"
Age=53
Salaire=1500000
Taille= 1.89

def afficher(self):
print([Link],[Link], [Link],[Link], [Link])

P=Personne()
[Link]()
P1=Personne()
[Link]()

8. Encapsulation

L'encapsulation est un concept fondamental de la programmation orientée objet (POO)

qui consiste à regrouper des données et les méthodes qui les manipulent au sein d'une
même entité, appelée classe. L'objectif principal de l'encapsulation est de cacher les
détails internes et de fournir une interface publique pour interagir avec les objets.

L'encapsulation permet de mettre en œuvre le principe de l'information cachée,

également connu sous le nom de principe d'occultation de l'information. Elle se base
sur les idées suivantes :
 Visibilité et accès contrôlé : Les membres d'une classe, tels que les attributs et les
méthodes, peuvent être déclarés avec différents niveaux de visibilité, tels que
public, ou privé. Cela détermine si ces membres sont accessibles à partir d'autres
parties du code. En général, les attributs sont déclarés comme privés et ne sont
accessibles qu'à l'intérieur de la classe, tandis que les méthodes sont déclarées
comme publiques et peuvent être utilisées pour accéder et modifier les attributs.
 Interface publique : L'encapsulation fournit une interface publique, également
appelée interface externe, qui expose les fonctionnalités et les opérations
disponibles pour interagir avec les objets de la classe. Cette interface publique est
composée des méthodes publiques de la classe, qui définissent comment les
utilisateurs externes peuvent interagir avec les objets.
 Séparation des responsabilités : En encapsulant les données et les méthodes dans
une classe, on crée une unité autonome qui a la responsabilité de gérer et de
manipuler ses propres données. Cela favorise la modularité et facilite la
maintenance du code, car les modifications internes n'affectent pas les utilisateurs
de la classe tant que l'interface publique reste inchangée.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 10
 Introduction à la Programmation Orientée Objet(POO) en Python

 Protection des données : En déclarant les attributs comme privés, on limite l'accès
direct aux données à l'intérieur de la classe. Cela permet de contrôler comment les
données sont modifiées et d'appliquer des validations ou des règles de gestion
appropriées avant de modifier les valeurs des attributs.
 Réduction de la complexité : L'encapsulation permet de cacher les détails de mise
en œuvre et de fournir une interface simplifiée pour les utilisateurs de la classe.
Cela réduit la complexité et facilite l'utilisation de l'objet, car les utilisateurs n'ont
besoin de connaître que l'interface publique pour interagir avec l'objet.

class Livre:

def __init__(self, titre, quantite, auteur, prix):

[Link] = titre
[Link] = quantite
[Link] = auteur
[Link] = prix
self.__remise = 0.1

def getRemise(self):
return self.__remise

def __repr__(self):
return f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix:
{[Link]}"

def detail(self):
print(f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix:
{[Link]}")

L1 = Livre('HTML', 12, 'TIAMA', 3000)

print([Link])
print([Link])
print([Link])
print([Link])
print([Link]())
try:
print(L1.__remise) # attribut cahé
except:
print("L'acces à la remise n'est pas autorisé!! Passez par un getteur")

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 11
 Introduction à la Programmation Orientée Objet(POO) en Python

9. Les Getters(Accesseurs)

Les getters, également connus sous le nom d'accesseurs, sont des méthodes utilisées
dans la programmation orientée objet (POO) pour accéder aux valeurs des attributs
privés d'une classe depuis l'extérieur de celle-ci. Les getters permettent d'obtenir les
valeurs des attributs sans accéder directement à ces derniers, en respectant ainsi le
principe d'encapsulation.

Les getters sont généralement définis avec les caractéristiques suivantes :

 Visibilité publique : Les getters sont déclarés comme des méthodes publiques afin
de permettre leur accès depuis l'extérieur de la classe.
 Nom explicite : Les getters sont généralement nommés avec un préfixe "get" suivi
du nom de l'attribut qu'ils permettent d'obtenir. Par exemple, si l'attribut est
nommé "age", le getter correspondant pourrait s'appeler "getAge()".
 Pas de paramètres : Les getters ne prennent généralement pas de paramètres, car
ils sont utilisés pour obtenir une valeur spécifique sans nécessiter d'arguments
supplémentaires.
 Retour de la valeur : Les getters retournent généralement la valeur de l'attribut
demandé, qui peut être de n'importe quel type (entier, chaîne de caractères, objet,
etc.). Le type de retour du getter doit correspondre au type de l'attribut.

L'utilisation des getters permet de maintenir l'encapsulation des données en limitant

l'accès direct aux attributs privés, tout en fournissant une interface publique pour
obtenir les valeurs de ces attributs. Cela permet de contrôler et de valider l'accès aux
données, d'appliquer des règles de logique métier si nécessaire, et de garantir une
utilisation cohérente et sécurisée des objets.

class Livre:

def __init__(self, titre, quantite, auteur, prix):

[Link] = titre
[Link] = quantite
[Link] = auteur
self.__prix = prix
self.__remise = None

def getRemise(self):
return self.__remise

def getPrix(self):
if self.__remise:
return self.__prix * (1-self.__remise)

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 12
 Introduction à la Programmation Orientée Objet(POO) en Python

return self.__prix

def setRemise(self, remise):

self.__remise=remise

def __repr__(self):
return f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix:
{[Link]()}"

def detail(self):
print(f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix:
{[Link]()}")

L1 = Livre('HTML', 12, 'TIAMA', 3000)

L2 = Livre('POO', 1, 'MATY Maman', 2000)
L3 = Livre('POO Promo', 25, 'MATY Maman', 2000)
print("Prix sans remise:" ,[Link]())
print("Prix avec remise:",[Link]()) }
print(L2)
print(L3)

10. Les Setters(Mutateurs)

Les setters, également connus sous le nom de mutateurs, sont des méthodes utilisées
dans la programmation orientée objet (POO) pour modifier les valeurs des attributs
privés d'une classe depuis l'extérieur de celle-ci. Les setters permettent de mettre à
jour les valeurs des attributs tout en respectant le principe d'encapsulation.

Les setters sont généralement définis avec les caractéristiques suivantes :

 Visibilité publique : Les setters sont déclarés comme des méthodes publiques
afin de permettre leur accès depuis l'extérieur de la classe.

 Nom explicite : Les setters sont généralement nommés avec un préfixe "set"
suivi du nom de l'attribut qu'ils permettent de modifier. Par exemple, si
l'attribut est nommé "age", le setter correspondant pourrait s'appeler
"setAge()".

 Paramètre(s) : Les setters prennent généralement un ou plusieurs paramètres

correspondant aux nouvelles valeurs des attributs à modifier. Les paramètres
peuvent être de n'importe quel type (entier, chaîne de caractères, objet, etc.).
Le nombre et le type des paramètres doivent correspondre aux attributs que le
setter modifie.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 13
 Introduction à la Programmation Orientée Objet(POO) en Python

 Pas de valeur de retour : Les setters ne retournent généralement pas de valeur,

car ils sont utilisés uniquement pour mettre à jour les attributs et n'ont pas
besoin de retourner une valeur spécifique.

L'utilisation des setters permet de maintenir l'encapsulation des données en limitant

l'accès direct aux attributs privés, tout en fournissant une interface publique pour
mettre à jour les valeurs de ces attributs. Cela permet de contrôler et de valider les
nouvelles valeurs assignées, d'appliquer des règles de logique métier si nécessaire, et
de garantir une utilisation cohérente et sécurisée des objets.

class Livre:

def __init__(self, titre, quantite, auteur, prix):

[Link] = titre
[Link] = quantite
[Link] = auteur
self.__prix = prix
self.__remise = 0.15

def getRemise(self):
return self.__remise

def getPrix(self):
if self.__remise:
return self.__prix * (1-self.__remise)
return self.__prix

def setRemise(self, remise):

self.__remise=remise

def __repr__(self):
return f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix: {[Link]()}"

def detail(self):
print(f"Livre: {[Link]}, Quantité: {[Link]}, Auteur: {[Link]}, Prix: {[Link]()}")

L1 = Livre('HTML', 12, 'TIAMA', 3000)

L2 = Livre('POO', 1, 'MATY Maman', 2000)
L3 = Livre('POO Promo', 25, 'MATY Maman', 2000)
[Link](0.20)
[Link]()

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 14
 Introduction à la Programmation Orientée Objet(POO) en Python

11. Applications

Exo d'application

1. Créer la classe "Voiture" avec les attributs marque, couleur, modèle, typecarburant,
réservoir, vitesse, vitesseMax roues, prix, stock et les methodes: démarrer,
accélérer,arreter, ajoutcarbunrant, infovoiture, etc
2. Créer la classe "Point" pour gérer les points avec comme attributs x et y, comme
méthodes, afficher, norme, determinant, produit scalaire
3. Créer les classes Retangle,Triangle, Cercle, Carré
4. Écrire un programme en Python qui simule la gestion d’un simple compte bancaire. Le
compte est créé avec un solde initial. Il est possible de déposer et de retirer des fonds,
d’ajouter des intérêts et de connaître le solde actuel. Cela devrait être implémenté dans
une classe nommée Account qui comprend:
 Un constructeur par défaut qui met le solde initial à zéro.
 un constructeur qui accepte une balance initial comme paramètre.
 Une fonction getBalance qui renvoie le solde actuel
 Une méthode deposer pour déposer un montant spécifié.
 Une méthode retirer pour retirer un montant spécifié.
 Une méthode ajouter_Interet pour ajouter de l’intérêt au compte
 La méthode ajouter_Interet prend le taux d’intérêt comme paramètre et modifie le
solde du compte en solde * (1 + taux d’intérêt).
5. Créer la classe Etudiant avec les attributs Matricule, nom, prenom, moyenne, rang,
mention et les méthodes nécessaires pour traiter les étudiants

6. Créer la classe Rectangle et calculer sa surface et on périmètre et dire si le triangle est

rectangle et en quel point?

7. Créer une classe Calcul avec :

 un constructeur par défaut (sans paramètres) permettant d’effectuer différents calculs sur
les nombres entiers.
 Créer au sein de la classe Calcul une méthode nommée Factorielle() qui permet de calculer le
factorielle d'un entier. Tester la méthode en faisant une instanciation sur la classe.
 Créer au sein de la classe Calcul une méthode nommée Somme() permettant de calculer
la somme des n premiers entiers: 1 + 2 + 3 + .. + n. Tester la méthode.
 Créer au sein de la classe Calcul une méthode nommée testPrim() permettant de tester
la primalité d'un entier donné. Tester la méthode.
 Créer au sein de la classe Calcul une méthode nommée testPrims() permettant de tester si
deux nombres sont premier entre eux.
 Créer une méthode tableMult() qui crée et affiche la table de multiplication d'un entier
donné. Créer ensuite une méthode allTablesMult() permettant d'afficher toutes les tables
de multiplications des entiers 1, 2, 3, ..., 9.
 Créer une méthode listDiv() qui récupère tous les diviseurs d'un entier donné sur une liste
Ldiv. Créer une autre méthode listDivPrim() qui récupère tous les diviseurs premiers d'un
entier donné.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 15
 Introduction à la Programmation Orientée Objet(POO) en Python

12. Héritage

L'héritage est un concept fondamental de la programmation orientée objet (POO) qui

permet de créer de nouvelles classes (appelées classes dérivées ou sous-classes) en
se basant sur des classes existantes (appelées classes de base ou superclasses).
L'héritage permet aux sous-classes d'hériter des attributs et des méthodes de la
classe de base, tout en leur permettant d'ajouter de nouvelles fonctionnalités ou de
modifier le comportement existant.

L'héritage est utilisé pour établir une relation "est-un" entre les classes, ce qui signifie
qu'une sous-classe est une version spécifique de sa classe de base. La classe de base
fournit un ensemble de fonctionnalités générales qui peuvent être réutilisées par les
sous-classes, tandis que les sous-classes peuvent ajouter des fonctionnalités
supplémentaires spécifiques à leur domaine d'application.

 Classe de base et sous-classes : La classe de base est la classe existante dont les
attributs et les méthodes sont hérités. Les sous-classes sont les nouvelles classes
créées qui héritent de la classe de base. Les sous-classes peuvent avoir leurs
propres attributs et méthodes en plus de ceux hérités.
 Relation "est-un" : L'héritage établit une relation "est-un" entre les classes, ce qui
signifie qu'une sous-classe est une version spécifique de la classe de base. Par
exemple, une classe de base "Animal" peut avoir des sous-classes telles que
"Chien", "Chat" et "Oiseau".
 Héritage des attributs et méthodes : Les sous-classes héritent des attributs et des
méthodes de la classe de base. Cela signifie que les sous-classes peuvent accéder
aux attributs et aux méthodes hérités comme s'ils leur appartenaient directement.
 Redéfinition (ou surcharge) : Les sous-classes peuvent redéfinir (ou surcharger) les
méthodes héritées pour modifier leur comportement ou les adapter aux besoins
spécifiques de la sous-classe. Cela permet de personnaliser le comportement
hérité sans modifier la classe de base.
 Niveaux d'héritage : L'héritage peut former une hiérarchie de plusieurs niveaux, où
une sous-classe peut devenir une classe de base pour d'autres sous-classes. Cela
permet de créer des structures d'héritage complexes pour modéliser des relations
entre des entités du monde réel.

L'héritage permet de favoriser la réutilisabilité du code, la modularité et la gestion de

la complexité en regroupant des fonctionnalités communes dans une classe de base
et en les partageant entre les sous-classes. Il facilite également la maintenance du
code, car les modifications apportées à la classe de base se répercutent
automatiquement sur les sous-classes.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 16
 Introduction à la Programmation Orientée Objet(POO) en Python

class Animal:
def parler(self):
print("Je parle")

class Chien(Animal):
def parler(self):
return "Woof !"

# Fonction qui prend un objet Animal en argument et appelle sa méthode parler

def faire_parler(animal):
print([Link]())

# Création d'instances de différentes classes d'animaux

chien1 = Chien()
chien2=Animal()

13. Le polymorphisme

Le polymorphisme est un concept clé de la programmation orientée objet (POO) qui

permet à un objet d'être traité comme un objet d'un type différent, tout en
conservant son comportement spécifique. Il permet de traiter des objets de
différentes classes de manière uniforme en utilisant des références ou des pointeurs
vers la classe de base.

Le polymorphisme repose sur deux concepts principaux : le polymorphisme statique

et le polymorphisme dynamique.

1. Polymorphisme statique (liaison statique) :

 Également connu sous le nom de liaison précoce.

 Se produit lors de la compilation.
 Utilise le mécanisme de surcharge de fonctions.
 Permet à des objets d'être traités différemment en fonction du type statique
(déclaré) des variables.

2. Polymorphisme dynamique (liaison dynamique) :

 Également connu sous le nom de liaison tardive ou de liaison dynamique.

 Se produit au moment de l'exécution.
 Utilise des pointeurs ou des références vers des objets.
 Permet de traiter des objets dérivés comme s'ils étaient des objets de la classe
de base, tout en préservant leur comportement spécifique.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 17
 Introduction à la Programmation Orientée Objet(POO) en Python

Le polymorphisme dynamique est généralement réalisé en utilisant des fonctions

virtuelles et des classes abstraites.

Le polymorphisme permet de traiter des objets de différentes classes de manière

uniforme en utilisant une interface commune. Cela favorise la flexibilité, la
réutilisation du code et une conception orientée objet plus modulaire et extensible.

class Animal:
def parler(self):
pass

class Chien(Animal):
def parler(self):
return "Woof !"

class Chat(Animal):
def parler(self):
return "Miaou !"

class Vache(Animal):
def parler(self):
return "Meuh !"

# Fonction qui prend un objet Animal en argument et appelle sa méthode parler

def faire_parler(animal):
print([Link]())

# Création d'instances de différentes classes d'animaux

chien = Chien()
chat = Chat()
vache = Vache()
# Appel de la fonction faire_parler avec différentes instances d'animaux
faire_parler(chien) # Affiche "Woof !"
faire_parler(chat) # Affiche "Miaou !"
faire_parler(vache) # Affiche "Meuh !"

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 18
 Introduction à la Programmation Orientée Objet(POO) en Python

14. La surcharge

La surcharge (ou surcharge de fonctions) est un concept de la programmation

orientée objet qui permet de définir plusieurs fonctions avec le même nom mais des
paramètres différents. La surcharge permet d'utiliser le même nom de fonction pour
effectuer des opérations similaires sur différents types de données.

La surcharge de fonctions se base sur les paramètres des fonctions pour les
différencier. Deux fonctions peuvent avoir le même nom si elles ont des listes de
paramètres différentes (nombre, types ou ordre des paramètres).

class Surcharge:

def ajouter(self, x, y):

print(x+y)

def ajouter(self, x, y, z):

print(x+y+z)

S = Surcharge()
[Link](2, 3,3)
[Link]('Maman', ' Maman', ' Siradji')

number = 10
print(number.__add__(20))
text="MATY"
print(text.__add__(" Maman"))

Dans cet exemple, nous avons deux fonctions nommées "addition", mais elles
prennent des types de paramètres différents. La première fonction "addition" prend
deux entiers en paramètres et renvoie leur somme, tandis que la deuxième fonction
"addition" prend deux chaînes de caractères en paramètres et renvoie leur
concaténation.

Lorsque nous appelons la fonction "addition" dans la fonction `main()`, le compilateur

sélectionne automatiquement la version appropriée de la fonction en fonction des
types de paramètres que nous passons.

La surcharge de fonctions permet d'améliorer la lisibilité du code et d'offrir plus de

flexibilité en permettant d'utiliser le même nom de fonction pour des opérations
similaires. Cela permet également d'encourager la réutilisation du code et d'adapter
les fonctions à différents types de données.

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 19
 Introduction à la Programmation Orientée Objet(POO) en Python

class Personne:
def __init__(self, nom, prenom,poids, age, salaire):
[Link] = nom
[Link] = prenom
[Link] = poids
[Link] = age
[Link] = salaire

def __add__(self, autre):

return [Link] + [Link]

p1 = Personne("MATY", "Maman",80, 53, 1500000)

p2 = Personne("GUIFO", "Danatien",70, 52, 1400000)
# p3 = Personne(70, 52, 1400000)
print(p1 + p2)

15. Interface et classe abstraite

En programmation orientée objet, une interface est une spécification de méthodes et

de comportements que doivent implémenter les classes qui en héritent. Une interface
définit un contrat ou un ensemble de règles que les classes doivent suivre. Elle
permet de définir un ensemble de méthodes abstraites (méthodes sans
implémentation) que les classes concrètes doivent fournir.

Les interfaces sont généralement réalisées à l'aide de classes abstraites contenant

uniquement des méthodes virtuelles pures, c'est-à-dire des méthodes déclarées sans
implémentation et précédées du mot-clé @abstractmethod. Une classe qui hérite
d'une interface doit fournir une implémentation pour toutes les méthodes déclarées
dans cette interface.

Bien que Python ne nécessite pas explicitement de déclarer une interface, vous
pouvez utiliser des classes abstraites de cette manière pour obtenir un comportement
similaire. Cela permet une meilleure organisation du code et garantit que certaines
fonctionnalités sont disponibles dans toutes les classes qui implémentent l'interface.

from abc import ABC, abstractmethod

class Personne(ABC):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance):

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 20
 Introduction à la Programmation Orientée Objet(POO) en Python

[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = nationalite
self.date_de_naissance = date_de_naissance

@abstractmethod
def afficher_informations(self):
pass

class Enseignant(Personne):
def __init__(self, matricule, nom, prenom, salaire, nationalite, date_de_naissance):
super().__init__(matricule, nom, prenom, nationalite, date_de_naissance)
[Link] = salaire

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Salaire:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Enseignant")

class Etudiant(Personne):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance):
super().__init__(matricule, nom, prenom, nationalite, date_de_naissance)

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Étudiant")

class Employe(Personne):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance, service,
categorie):
super().__init__(matricule, nom, prenom, nationalite, date_de_naissance)
[Link] = service
[Link] = categorie
def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 21
 Introduction à la Programmation Orientée Objet(POO) en Python

print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Service:", [Link])
print("Catégorie:", [Link])
print("Statut: Employé")

# Exemple d'utilisation
enseignant = Enseignant(matricule="123", nom="MATY", prenom="Maman",
salaire=300000, nationalite="Nigérienne", date_de_naissance="01/01/1971")
etudiant = Etudiant(matricule="456", nom="MAMAN MATY", prenom="Faridah",
nationalite="Gabonaise", date_de_naissance="12/09/2001")
employe = Employe(matricule="789", nom="OSSENE", prenom="Raoul",
nationalite="Gabonaise", date_de_naissance="10/10/1985", service="RH",
categorie="Cadre")

enseignant.afficher_informations()
print("\n")
etudiant.afficher_informations()
print("\n")
employe.afficher_informations()

Interface

from abc import ABC, abstractmethod

class IPersonne(ABC):
@abstractmethod
def afficher_informations(self):
pass

class Enseignant(IPersonne):
def __init__(self, matricule, nom, prenom, salaire, nationalite, date_de_naissance):
[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = salaire
[Link] = nationalite
self.date_de_naissance = date_de_naissance

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 22
 Introduction à la Programmation Orientée Objet(POO) en Python

print("Salaire:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Enseignant")

class Etudiant(IPersonne):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance):
[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = nationalite
self.date_de_naissance = date_de_naissance

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Étudiant")

class Employe(IPersonne):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance, service,
categorie):
[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = nationalite
self.date_de_naissance = date_de_naissance
[Link] = service
[Link] = categorie

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Service:", [Link])
print("Catégorie:", [Link])
print("Statut: Employé")

# Exemple d'utilisation
enseignant = Enseignant(matricule="123", nom="MATY", prenom="Maman",
salaire=300000, nationalite="Nigérienne", date_de_naissance="01/01/1971")

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 23
 Introduction à la Programmation Orientée Objet(POO) en Python

etudiant = Etudiant(matricule="456", nom="MAMAN MATY", prenom="Faridah",

nationalite="Gabonaise", date_de_naissance="12/09/2001")
employe = Employe(matricule="789", nom="OSSENE", prenom="Raoul",
nationalite="Gabonaise", date_de_naissance="10/10/1985", service="RH",
categorie="Cadre")

enseignant.afficher_informations()
print("\n")
etudiant.afficher_informations()
print("\n")
employe.afficher_informations()

16. Implémentation

En programmation orientée objet, l'implémentation fait référence à la manière dont

les méthodes et les fonctionnalités d'une classe sont concrètement mises en œuvre.
Elle se concentre sur les détails internes de la classe, tels que les algorithmes, les
structures de données et les opérations spécifiques qui réalisent le comportement
défini par l'interface de la classe.

L'implémentation d'une classe consiste à fournir les définitions complètes des

méthodes déclarées dans l'interface de la classe. Ces définitions décrivent comment
les méthodes sont effectivement exécutées, quels calculs sont effectués, quels
attributs de la classe sont utilisés et toute autre logique nécessaire pour accomplir la
fonctionnalité spécifique de la méthode.

Il est important de noter que l'interface et l'implémentation sont deux aspects

distincts d'une classe en POO. L'interface définit le contrat et les méthodes
disponibles pour les utilisateurs de la classe, tandis que l'implémentation détaille
comment ces méthodes sont réalisées en interne.

from abc import ABC, abstractmethod

class IPersonne(ABC):
@abstractmethod
def afficher_informations(self):
pass

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 24
 Introduction à la Programmation Orientée Objet(POO) en Python

class Enseignant(IPersonne):
def __init__(self, matricule, nom, prenom, salaire, nationalite, date_de_naissance):
[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = salaire
[Link] = nationalite
self.date_de_naissance = date_de_naissance

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Salaire:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Enseignant")

def augmenter_salaire(self, augmentation):

[Link] += augmentation
print(f"Le salaire de {[Link]} {[Link]} a été augmenté. Nouveau salaire : {[Link]}")

# Exemple d'utilisation
enseignant = Enseignant(matricule="123", nom="MATY", prenom="Maman", salaire=300000,
nationalite="Nigérienne", date_de_naissance="01/01/1971")
enseignant.afficher_informations()
enseignant.augmenter_salaire(500)

class Etudiant(IPersonne):
def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance):
[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = nationalite
self.date_de_naissance = date_de_naissance

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Statut: Étudiant")

def inscription_cours(self, cours):

print(f"L'étudiant {[Link]} {[Link]} est inscrit au cours de {cours}")

# Exemple d'utilisation
etudiant = Etudiant(matricule="456", nom="MAMAN MATY", prenom="Faridah",
nationalite="Gabonaise", date_de_naissance="12/09/2001")
etudiant.afficher_informations()
etudiant.inscription_cours("Mathématiques")
class Employe(IPersonne):
Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 25
 Introduction à la Programmation Orientée Objet(POO) en Python

def __init__(self, matricule, nom, prenom, nationalite, date_de_naissance, service, categorie):

[Link] = matricule
[Link] = nom
[Link] = prenom
[Link] = nationalite
self.date_de_naissance = date_de_naissance
[Link] = service
[Link] = categorie

def afficher_informations(self):
print("Matricule:", [Link])
print("Nom:", [Link])
print("Prénom:", [Link])
print("Nationalité:", [Link])
print("Date de naissance:", self.date_de_naissance)
print("Service:", [Link])
print("Catégorie:", [Link])
print("Statut: Employé")

def promotion(self, nouvelle_categorie):

[Link] = nouvelle_categorie
print(f"{[Link]} {[Link]} a été promu à la catégorie {[Link]}")

# Exemple d'utilisation
employe = Employe(matricule="789", nom="OSSENE", prenom="Raoul", nationalite="Gabonaise",
date_de_naissance="10/10/1985", service="RH", categorie="Cadre")
employe.afficher_informations()
[Link]("Senior")

Réalisé par MATY Maman Enseignant Permanent à l’Institut Africain d’Informatique Page : 26