Cours simplifié : Programmation Orientée
Objet (POO) en Python
1. Qu’est-ce que la POO ?
La Programmation Orientée Objet (POO) est une façon d’organiser le code en
utilisant des objets. Un objet regroupe : - des données (appelées attributs),
- des fonctions (appelées méthodes).
La POO sert à rendre le code plus clair, mieux organisé et réutilisable.
2. Les notions essentielles
Classe
Une classe est un modèle, une “forme” permettant de créer des objets.
class Personne:
pass
Objet
Un objet est une instance (un exemple concret) créé à partir d’une classe.
p = Personne()
3. Le constructeur __init__
Il permet d’initialiser un objet lorsque celui-ci est créé.
class Personne:
def __init__(self, nom, age):
[Link] = nom
[Link] = age
p = Personne("Alice", 22)
4. Les méthodes
Ce sont des fonctions définies dans la classe.
class Personne:
def __init__(self, nom, age):
[Link] = nom
[Link] = age
def se_presenter(self):
return f"Je m'appelle {[Link]} et j'ai {[Link]} ans."
p = Personne("Bob", 30)
print(p.se_presenter())
5. L’encapsulation
On peut protéger certaines données grâce à des attributs privés.
class CompteBancaire:
def __init__(self, solde):
self.__solde = solde # attribut privé
6. L’héritage
Une classe peut hériter d’une autre.
class Animal:
def parler(self):
return "?"
class Chien(Animal):
def parler(self):
return "Wouf !"
c = Chien()
print([Link]())
7. Le polymorphisme
Plusieurs classes différentes peuvent avoir une méthode portant le même
nom.
class Chat:
def parler(self):
return "Miaou"
class Chien:
def parler(self):
return "Wouf"
animaux = [Chat(), Chien()]
for a in animaux:
print([Link]())
8. Exemple complet
class Voiture:
def __init__(self, marque, modele):
[Link] = marque
[Link] = modele
def description(self):
return f"Voiture : {[Link]} {[Link]}"
v = Voiture("Toyota", "Corolla")
print([Link]())
Conclusion
La POO permet : - d’organiser le code, - de le réutiliser facilement, - de le
rendre plus clair et évolutif.
Si tu veux, je peux aussi : ✔ Donner des exercices ✔ Ajouter des schémas ✔
Faire un cours encore plus simplifié ✔ Ajouter plus d’exemples
9. Les attributs de classe vs attributs d’instance
Attribut d’instance
Il appartient uniquement à un objet.
class Exemple:
def __init__(self):
self.x = 10 # attribut d'instance
Chaque objet aura sa propre valeur de x.
Attribut de classe
Partagé entre toutes les instances.
class Exemple:
compteur = 0 # attribut de classe
def __init__(self):
[Link] += 1
10. Les propriétés (@property)
Elles permettent de contrôler l’accès aux attributs.
class Personne:
def __init__(self, age):
self.__age = age
@property
def age(self):
return self.__age
@[Link]
def age(self, valeur):
if valeur >= 0:
self.__age = valeur
Permet de protéger les données tout en gardant une syntaxe simple.
11. Les classes abstraites
Elles définissent des modèles de comportement.
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def parler(self):
pass
Une classe qui hérite doit obligatoirement implémenter parler().
12. Le concept d’interface
Python n’a pas d’interfaces formelles, mais on peut simuler ce
comportement avec des classes abstraites. Les interfaces garantissent
qu’une classe possède certaines méthodes.
13. Le polymorphisme avancé
Le polymorphisme rend possible l’utilisation d’un même nom de méthode
pour différentes classes.
def faire_parler(animal):
print([Link]())
Tant que l’objet a une méthode parler(), il sera accepté.
14. La surcharge (overloading) et redéfinition (overriding)
Overriding
Une sous-classe réécrit une méthode de la classe mère.
class Animal:
def parler(self):
return "?"
class Chat(Animal):
def parler(self):
return "Miaou"
Overloading
Python ne supporte pas nativement la surcharge. On utilise souvent des
valeurs par défaut.
def addition(a, b=0):
return a + b
15. Composition vs Héritage
Héritage : “est un” (ex : un Chien est un Animal).
Composition : “a un” (ex : une Voiture a un Moteur).
class Moteur:
pass
class Voiture:
def __init__(self):
[Link] = Moteur() # composition
16. Les méthodes spéciales (Méthodes magiques)
Elles commencent et finissent par __. Elles permettent de personnaliser le
comportement des objets. Exemples : - __str__() : représentation en texte -
__len__() : longueur - __add__() : opérateur +
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"({self.x}, {self.y})"
17. Exemple complet POO avancé
class Compte:
taux_interet = 0.02 # Attribut de classe
def __init__(self, proprietaire, solde=0):
[Link] = proprietaire
self.__solde = solde
@property
def solde(self):
return self.__solde
def depot(self, montant):
self.__solde += montant
def retrait(self, montant):
if montant <= self.__solde:
self.__solde -= montant
else:
print("Solde insuffisant.")
def __str__(self):
return f"Compte de {[Link]}, Solde: {self.__solde}
€"
Si tu veux aller plus loin
Je peux également ajouter : - un chapitre sur les design patterns POO
(Singleton, Factory, MVC…) - des exercices progressifs avec corrigés - un
schéma visuel explicatif - un mini-projet complet en POO