UNIVERSITE D’ABOMEY-CALAVI (UAC)

*********
ÉCOLE NATIONALE D’ÉCONOMIE APPLIQUÉE ET DE MANAGEMENT (ENEAM)
*********
CYCLE DES INGENIEURS STATISTICIENS ECONOMISTES (ISE)

Matière : Algorithmique et
Niveau : ISE 1
programmation avec Python

PROGRAMMATION ORIENTÉE OBJET (POO)

Réalisé par : Sous la supervision

de :
AZONLEGBE Noël Junior Dr Vinasetan Ratheil
DESSOUASSI Ezéchiel
PLAN
 Présentation générale

La programmation orientée objet (POO) est un paradigme de programmation qui repose

sur le concept d'objets, des entités regroupant des données (attributs) et des
Définition de la
fonctionnalités (méthodes). En Python, un objet est une collection de données et de
Programmation Orientée
Objet (POO) comportements, similaire à des entités du monde réel. Par exemple, une calculatrice
peut être modélisée comme un objet avec des données telles que les chiffres et des
méthodes telles que les opérations arithmétiques.

La POO est cruciale pour le développement logiciel, permettant la création de

Importance de la POO
dans le développement
logiciel
code clair, structuré, modulable et facile à maintenir. De nombreux frameworks
et bibliothèques Python, tels que Django, Kivy, pandas, NumPy, et TensorFlow,
utilisent la POO pour construire des bases de code robustes. De plus, la POO est
largement adoptée dans de nombreux langages de programmation modernes,
offrant une portabilité des compétences et une augmentation de la productivité.

La POO a émergé dans les années 1960 avec le langage Simula, mais c'est avec le
développement de Smalltalk dans les années 1970 que les concepts fondamentaux ont
Historique de la POO et été solidifiés. Des langages tels que C++, Objective-C, et Java ont ensuite élargi
son évolution l'influence de la POO. Aujourd'hui, la POO est une approche modulaire largement
utilisée dans le développement logiciel.
 Principes fondamentaux de la POO
Classes et objets
Classe: Une classe en POO est une structure définissant des
attributs (variables) et des méthodes (fonctions) pour créer des
objets. Exemple: la classe "Voiture" peut avoir des attributs tels
que la marque, le modèle, et des méthodes telles que
démarrer().
Objet: Un objet est une instance d'une classe, contenant des
attributs et des méthodes. L'instanciation, processus de
création d'un objet à partir d'une classe, permet de créer des
instances, comme une voiture spécifique avec une marque
particulière.
Encapsulation
Protection des données: L'encapsulation consiste à
regrouper des données (attributs) et des méthodes au sein
d'une structure, cachant l'implémentation. L'accès aux
données se fait uniquement par les méthodes, assurant
l'intégrité des données.
Utilisation de méthodes pour accéder aux données
encapsulées: Les accesseurs (getters) et mutateurs
(setters) sont utilisés pour lire et modifier les données
encapsulées, garantissant un accès contrôlé et évitant
la corruption des données.
 Principes fondamentaux de la POO (Suite)
Héritage
Notion d'héritage: L'héritage permet à une classe d'hériter des
propriétés et des méthodes d'une autre classe, créant une
hiérarchie. Une classe enfant hérite des propriétés de sa classe
parente.
Avantages de l'héritage dans la POO: L'héritage permet de
construire des classes dérivées, étendant les fonctionnalités
d'une classe de base. Cela favorise la réutilisation du code et la
création de hiérarchies logiques.
Polymorphisme
Notion de polymorphisme: Le polymorphisme en POO
permet à des fonctions et méthodes de même nom d'avoir
des comportements différents selon le contexte. Deux
types de polymorphisme existent : la surcharge et la
redéfinition.
Exemples de polymorphisme en Python: La surcharge
(overloading) permet de choisir entre différentes
implémentations d'une fonction selon le nombre et le
type des arguments fournis. La redéfinition
(overriding), liée à l'héritage, permet de modifier le
comportement des méthodes pour les adapter aux
besoins d'une classe dérivée.
 Implémentation en Python
Définition d'une classe et manipulation d’objets Encapsulation en python
class Personne:
class Personne: def __init__(self, nom, age):
def __init__(self, nom, age): self.__nom = nom
self.nom = nom self.__age = age
self.age = age
def afficher_infos(self):
def afficher_infos(self): print(f"Nom : {self.__nom}, Âge : {self.__age} ans")
print(f"Nom : {self.nom}, Âge : {self.age} ans")
# Getter pour le nom
def __str__(self): def get_nom(self):
return f"{self.nom}, {self.age} ans" return self.__nom

# Instanciation d'un objet de la classe Personne # Setter pour le nom

john_doe = Personne("John Doe", 30)
# Utilisation de la méthode afficher_infos
john_doe.afficher_infos() # Affiche : Nom : John Doe, Âge : 30 ans
# Utilisation de la méthode spéciale __str__
print(str(john_doe))
# Accès aux attributs de l'objet
print(john_doe.nom) # Affiche : John Doe
print(john_doe.age) # Affiche : 30
def set_nom(self, nouveau_nom):
self.__nom = nouveau_nom
# Instanciation d'un objet de la classe Personne
john_doe = Personne("John Doe", 30)
# Utilisation du getter pour le nom
nom_personne = john_doe.get_nom()
print(nom_personne) # Affiche : John Doe
# Utilisation du setter pour le nom
john_doe.set_nom("Jane Doe")
john_doe.afficher_infos() # Affiche : Nom : Jane Doe, Âge : 30 ans
 Implémentation en Python (Suite)
Héritage en Python Exemple de polymorphisme

class Employe(Personne): class Chien:

def __init__(self, nom, age, emploi): def produire_son(self):
super().__init__(nom, age) return "Abouh abouh!"
self.emploi = emploi
class Chat:
def produire_son(self):
def afficher_emploi(self):
return "Miaou miaou!"
print(f"Emploi : {self.emploi}")

#redéfinition de la méthode `afficher_infos` dans la classe `Employe` : def faire_sonner(animal):

def afficher_infos(self): return animal.produire_son()
print(f"Nom : {self.nom}, Âge : {self.age} ans, Emploi : {self.emploi}")
# Création d'objets
# Instanciation d'un objet de la classe Employe rex = Chien()
john_employe = Employe("John Doe", 30, "Développeur") minou = Chat()

# Appels de la fonction avec différents objets

# Utilisation des méthodes héritées et surchargées
print(faire_sonner(rex)) # Affiche : Abouh abouh!
john_employe.afficher_infos()
Print(faire_sonner(minou)) # Affiche : Miaou miaou!
# Affiche : Nom : John Doe, Âge : 30 ans, Emploi : Développeur
john_employe.afficher_emploi()
# Affiche : Emploi : Développeur
 Applications pratiques de la POO en Python
Exemple : Système de Gestion de Boutique en Ligne

class Produit: #APPLICATION :

def __init__(self, nom, prix, disponibilite):
self.nom = nom # Création de produits
self.prix = prix produit1 = Produit("Ordinateur portable", 1200.00, True)
self.disponibilite = disponibilite produit2 = Produit("Souris sans fil", 25.00, True)

class Client: # Création d'un client

def __init__(self, nom, adresse): client1 = Client("Alice", "123 Rue de la République")
self.nom = nom
self.adresse = adresse # Le client passe une commande
self.commandes = [ ] client1.passer_commande(produit1, 2)
client1.passer_commande(produit2, 1)
def passer_commande(self, produit, quantite):
commande = Commande(produit, quantite) # Affichage des informations sur le client et ses commandes
self.commandes.append(commande) print(f"Nom du client : {client1.nom}")
print(f"Adresse du client : {client1.adresse}")
class Commande:
def __init__(self, produit, quantite): print("\nCommandes du client :")
self.produit = produit for index, commande in enumerate(client1.commandes, 1):
self.quantite = quantite print(f"Commande {index}: {commande.quantite} x {commande.produit.nom} - Prix
unitaire : {commande.produit.prix}, Disponible : {commande.produit.disponibilite}")
Applications pratiques de la POO en Python (Suite)

Avantages de la POO dans la gestion de projets complexes

Création de modules
indépendants et
autonomes

Favorise la
collaboration et la Réutilisabilité du Code
gestion d’équipe

Héritage(centralisation
Facilitation de la des modifications à la
Maintenance classe parent)
MERCI POUR VOTRE
ATTENTION