Guide Python pour Débutants — Volume 3
Programmation Orientée Objet
Ce guide introduit la Programmation Orientée Objet (POO) en Python. Vous apprendrez à créer
des classes, des objets, à utiliser l'héritage et à appliquer les principes fondamentaux de la
POO.
Chapitre 1 — Introduction à la POO
La Programmation Orientée Objet (POO) est un paradigme de programmation qui organise le
code autour d'objets plutôt que de fonctions. Un objet est une instance d'une classe.
Les 4 piliers de la POO sont :
1. Encapsulation : regrouper données et méthodes dans une même entité.
2. Héritage : une classe peut hériter des attributs et méthodes d'une autre.
3. Polymorphisme : des objets de classes différentes peuvent répondre à la même interface.
4. Abstraction : cacher la complexité interne et n'exposer que l'essentiel.
Chapitre 2 — Créer une classe
Syntaxe de base
class Animal:
"""Classe représentant un animal."""
# Variable de classe (partagée par tous les animaux)
nb_animaux = 0
def __init__(self, nom, espece, age):
"""Constructeur — appelé à la création de l'objet."""
[Link] = nom # Attributs d'instance
[Link] = espece
[Link] = age
Animal.nb_animaux += 1
def se_presenter(self):
"""Méthode d'instance."""
return f"Je m'appelle {[Link]}, je suis un(e) {[Link]}."
def __str__(self):
"""Représentation en string de l'objet."""
return f"Animal({[Link]}, {[Link]}, {[Link]} ans)"
# Créer des objets
chat = Animal("Mimi", "Chat", 3)
chien = Animal("Rex", "Chien", 5)
print(chat.se_presenter())
print(chien)
print(f"Nombre d'animaux : {Animal.nb_animaux}")
Chapitre 3 — Héritage
L'héritage permet à une classe enfant de réutiliser et d'étendre les fonctionnalités d'une classe
parent.
class Animal:
def __init__(self, nom, age):
[Link] = nom
[Link] = age
def manger(self):
return f"{[Link]} mange."
def dormir(self):
return f"{[Link]} dort."
class Chien(Animal): # Hérite de Animal
def __init__(self, nom, age, race):
super().__init__(nom, age) # Appel du constructeur parent
[Link] = race
def aboyer(self):
return f"{[Link]} aboie : Woof !"
def manger(self): # Surcharge (override)
return f"{[Link]} mange sa croquette de chien."
class Chat(Animal):
def __init__(self, nom, age, interieur=True):
super().__init__(nom, age)
[Link] = interieur
def miauler(self):
return f"{[Link]} miaule : Miaou !"
rex = Chien("Rex", 4, "Labrador")
mimi = Chat("Mimi", 2)
print([Link]()) # Surcharge
print([Link]()) # Méthode du parent
print([Link]())
print([Link]())
print([Link]()) # Hérité du parent
Chapitre 4 — Encapsulation
L'encapsulation permet de protéger les attributs d'une classe. En Python, la convention est
d'utiliser un underscore _ pour les attributs "protégés" et deux underscores __ pour les attributs
"privés".
class CompteBancaire:
def __init__(self, titulaire, solde_initial=0):
[Link] = titulaire
self.__solde = solde_initial # Attribut privé
def deposer(self, montant):
if montant > 0:
self.__solde += montant
print(f"Dépôt de {montant}€. Solde : {self.__solde}€")
else:
print("Montant invalide.")
def retirer(self, montant):
if 0 < montant <= self.__solde:
self.__solde -= montant
print(f"Retrait de {montant}€. Solde : {self.__solde}€")
else:
print("Solde insuffisant ou montant invalide.")
@property
def solde(self): # Getter
return self.__solde
def __str__(self):
return f"Compte de {[Link]} — Solde : {self.__solde}€"
compte = CompteBancaire("Alice", 1000)
[Link](500)
[Link](200)
print([Link]) # Via le getter
print(compte)
Chapitre 5 — Méthodes spéciales (dunder methods)
Python définit des méthodes spéciales entourées de doubles underscores (__). Elles permettent
de définir le comportement des objets avec les opérateurs Python.
class Vecteur:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"Vecteur({self.x}, {self.y})"
def __repr__(self):
return f"Vecteur(x={self.x}, y={self.y})"
def __add__(self, autre): # Opérateur +
return Vecteur(self.x + autre.x, self.y + autre.y)
def __mul__(self, scalaire): # Opérateur *
return Vecteur(self.x * scalaire, self.y * scalaire)
def __len__(self): # Fonction len()
return int((self.x**2 + self.y**2)**0.5)
def __eq__(self, autre): # Opérateur ==
return self.x == autre.x and self.y == autre.y
v1 = Vecteur(3, 4)
v2 = Vecteur(1, 2)
print(v1 + v2) # Vecteur(4, 6)
print(v1 * 2) # Vecteur(6, 8)
print(len(v1)) # 5
print(v1 == v2) # False
Chapitre 6 — Exemple complet : Système de bibliothèque
class Livre:
def __init__(self, titre, auteur, isbn):
[Link] = titre
[Link] = auteur
[Link] = isbn
[Link] = True
def __str__(self):
statut = "Disponible" if [Link] else "Emprunté"
return f'"{[Link]}" par {[Link]} [{statut}]'
class Bibliotheque:
def __init__(self, nom):
[Link] = nom
[Link] = []
def ajouter_livre(self, livre):
[Link](livre)
print(f"Livre ajouté : {[Link]}")
def emprunter(self, isbn):
for livre in [Link]:
if [Link] == isbn and [Link]:
[Link] = False
return f"Emprunt OK : {[Link]}"
return "Livre non disponible."
def retourner(self, isbn):
for livre in [Link]:
if [Link] == isbn:
[Link] = True
return f"Retour OK : {[Link]}"
return "Livre non trouvé."
def afficher_catalogue(self):
print(f"=== Catalogue : {[Link]} ===")
for livre in [Link]:
print(f" {livre}")
# Utilisation
bib = Bibliotheque("Médiathèque Centrale")
bib.ajouter_livre(Livre("Le Petit Prince", "Saint-Exupéry", "978-1"))
bib.ajouter_livre(Livre("1984", "George Orwell", "978-2"))
bib.afficher_catalogue()
print([Link]("978-1"))
bib.afficher_catalogue()
Exercices pratiques — Testez vos connaissances
Exercice 1 : Créez une fonction qui prend une liste d'entiers et retourne la somme des nombres
pairs.
Exercice 2 : Écrivez un programme qui lit un fichier texte et compte le nombre d'occurrences de
chaque mot.
Exercice 3 : Implémentez une calculatrice simple avec les 4 opérations de base en utilisant des
fonctions.
Exercice 4 : Créez une classe Rectangle avec des méthodes pour calculer l'aire et le périmètre.
Exercice 5 : Écrivez un programme qui génère les 20 premiers nombres de la suite de Fibonacci.
Exercice 6 : Créez un dictionnaire qui associe chaque lettre de l'alphabet à sa position (a=1, b=2...).
Exercice 7 : Implémentez une fonction de recherche binaire dans une liste triée.
Exercice 8 : Créez un programme qui simule le jeu du Pendu avec un mot choisi aléatoirement.
Exercice 9 : Écrivez une fonction récursive pour calculer le factoriel d'un nombre.
Exercice 10 : Créez un gestionnaire de contacts (ajout, suppression, recherche) avec des
dictionnaires.
Solutions et conseils
Solution Exercice 1 : def somme_pairs(lst): return sum(x for x in lst if x % 2 == 0)
Solution Exercice 5 : fib = [0,1]; [[Link](fib[-1]+fib[-2]) for _ in range(18)]; print(fib[:20])
Solution Exercice 9 : def factoriel(n): return 1 if n <= 1 else n * factoriel(n-1)
Ressources supplémentaires
Pour approfondir vos connaissances en Python, voici quelques ressources recommandées par la
communauté :
- Real Python ([Link]) : tutoriels détaillés et articles approfondis sur tous les aspects de
Python.
- Python Docs ([Link]) : la documentation officielle, indispensable pour tout développeur
Python.
- Automate the Boring Stuff with Python ([Link]) : livre gratuit en ligne, idéal
pour débutants.
- CS50P ([Link]/python) : cours gratuit de Harvard Introduction to Programming with
Python.
- PyPI ([Link]) : l'index des packages Python, plus de 400 000 bibliothèques disponibles.
Glossaire Python
Variable : Un espace mémoire nommé qui stocke une valeur. En Python, les variables sont
dynamiquement typées.
Fonction : Un bloc de code réutilisable qui effectue une tâche spécifique. Définie avec le mot-clé
def.
Classe : Un modèle pour créer des objets. Elle définit les attributs et les méthodes de ses
instances.
Module : Un fichier Python contenant du code (fonctions, classes, variables) réutilisable dans
d'autres fichiers.
Bibliothèque : Une collection de modules regroupés pour offrir des fonctionnalités spécifiques.
Exception : Une erreur qui survient pendant l'exécution du programme. Gérée avec try/except.
Itérateur : Un objet qui peut être parcouru élément par élément avec une boucle for.
Générateur : Une fonction qui produit des valeurs à la demande avec yield, économisant la
mémoire.
Décorateur : Une fonction qui modifie le comportement d'une autre fonction sans la modifier
directement.
Lambda : Une fonction anonyme définie en une seule ligne : lambda x: x * 2
