C.1 Coder une solution orientée objet complète

1Situer

Le directeur d'un centre de formation à Kénitra demande une petite application : gérer les stagiaires et les formateurs, les regrouper par groupe, calculer la moyenne d'un groupe et afficher la fiche de chaque personne. C'est le moment d'assembler tout ce que vous avez appris : chaque concept de la POO trouve sa place dans ce mini-projet.

2Comprendre

Organiser un projet en package

Tout le projet tient dans un seul fichier de 800 lignes : difficile à lire et à partager.

1 / 5

Coder une solution orientée objet, c’est d’abord concevoir, puis organiser, puis coder et tester.

1. Concevoir les classes

À partir de l’énoncé, on souligne les noms (stagiaire, formateur, groupe, note) : ce sont des candidats classes ou attributs. Les verbes (inscrire, calculer, afficher) deviennent des méthodes. On note les liens :

« est un » → héritage (un stagiaire est une personne) ;
« a un / contient » → composition (un groupe contient des stagiaires).

Exemple simple

Repérer les classes dans un énoncé

« Une bibliothèque prête des livres à des adhérents. Chaque emprunt a une date de retour. » Les noms deviennent des classes, les verbes des méthodes.

Bibliotheque : livres, adherents      → preter(livre, adherent)
Livre        : titre, auteur, dispo
Adherent     : nom, emprunts
Emprunt      : livre, adherent, date_retour → est_en_retard()

Ce qui se passe

Noms importants : bibliothèque, livre, adhérent, emprunt.
Verbes : prêter (méthode de Bibliotheque), être en retard (méthode d’Emprunt).

2. Organiser en package

Un package est un dossier qui regroupe des modules (fichiers .py), avec un fichier __init__.py :

centre/
├── __init__.py
├── personnes.py
└── groupes.py
main.py

Dans main.py : from centre.personnes import Stagiaire.

Exemple simple

Un fichier par classe

On range les classes dans un dossier-package pour s’y retrouver.

bibliotheque/
├── __init__.py
├── livre.py        class Livre
├── adherent.py     class Adherent
└── emprunt.py      class Emprunt
main.py             from bibliotheque.livre import Livre

3. Intégrer les concepts

Concept	Où dans le projet
encapsulation	notes privées, ajout contrôlé par `ajouter_note()`
héritage	Stagiaire et Formateur héritent de Personne
polymorphisme	`print(p)` appelle la bonne `fiche()`
abstraction	Personne est abstraite, `fiche()` est obligatoire
interface	on pourrait ajouter `Imprimable` pour les fiches PDF

Exemple simple

Encapsulation, héritage et polymorphisme dans un même projet

Les trois concepts se combinent naturellement.

class Document:                       # parent commun
    def __init__(self, titre):
        self._titre = titre           # encapsulé
    def duree_pret(self):
        return 14

class Livre(Document): pass           # héritage
class Revue(Document):
    def duree_pret(self):             # polymorphisme
        return 7

for d in [Livre("Le Petit Prince"), Revue("Science & Vie")]:
    print(d.duree_pret(), "jours")

4. Tester au fur et à mesure

Après chaque classe, créez deux ou trois objets et affichez-les. Un bug trouvé tout de suite se corrige en une minute.

Exemple simple

Un test simple avec assert

assert vérifie qu’une condition est vraie. Si ce n’est pas le cas, le programme s’arrête et signale le problème.

e = Emprunt(Livre("Nedjma"), Adherent("Sara"), jours=14)
assert e.est_en_retard(jour=10) is False
assert e.est_en_retard(jour=20) is True
print("Tous les tests passent")

Ce qui se passe

On teste chaque classe dès qu’elle est écrite, avant de passer à la suivante.
Si une assertion échoue, on sait tout de suite quelle méthode corriger.

Exemple simple

Ranger sa chambre

Les vêtements dans l'armoire, les livres sur l'étagère, les chaussures dans le placard. Un package, c'est pareil : un dossier pour le projet, un fichier par sujet. On retrouve tout plus vite.

centre/
├── __init__.py
├── personnes.py
└── groupes.py
main.py

Exemple simple

D'abord le schéma, ensuite le code

Avant de coder, on dessine les classes et leurs liens sur papier : qui hérite de qui, qui contient quoi. Cinq minutes de schéma économisent une heure de corrections.

Personne (abstraite)
├── Stagiaire   a des notes
└── Formateur   a une spécialité
Groupe          contient des Stagiaire

3Manipuler

Exécutez le mini-projet. Observez la mémoire : le groupe contient des stagiaires, qui héritent de Personne. Ajoutez un stagiaire avec ses notes et relancez.

Pas à pas dans le lab ↗Python se charge au premier clic (environ 12 Mo, une seule fois).

from abc import ABC, abstractmethod

class Personne(ABC):                              # abstraction
    def __init__(self, nom, prenom):
        self.nom, self.prenom = nom, prenom

@abstractmethod
    def fiche(self): ...

def __str__(self):                            # polymorphisme
        return self.fiche()

class Stagiaire(Personne):                        # héritage
    def __init__(self, nom, prenom, matricule):
        super().__init__(nom, prenom)
        self.matricule = matricule
        self.__notes = []                         # encapsulation

def ajouter_note(self, note):
        if not 0 <= note <= 20:
            raise ValueError("note entre 0 et 20")
        self.__notes.append(note)

@property
    def moyenne(self):
        return round(sum(self.__notes) / len(self.__notes), 2) if self.__notes else 0

def fiche(self):
        return f"[Stagiaire] {self.prenom} {self.nom} ({self.matricule}) : {self.moyenne}/20"

class Formateur(Personne):
    def __init__(self, nom, prenom, specialite):
        super().__init__(nom, prenom)
        self.specialite = specialite

def fiche(self):
        return f"[Formateur] {self.prenom} {self.nom}, {self.specialite}"

class Groupe:                                     # composition
    def __init__(self, code, formateur):
        self.code, self.formateur = code, formateur
        self.stagiaires = []

def inscrire(self, s):
        self.stagiaires.append(s)

def moyenne(self):
        ms = [s.moyenne for s in self.stagiaires]
        return round(sum(ms) / len(ms), 2) if ms else 0

prof = Formateur("Bennani", "Rachid", "Développement")
g = Groupe("DEV101", prof)
for nom, prenom, mat, notes in [("Idrissi", "Salma", "S01", [15, 17, 13]),
                                ("Tazi", "Omar", "S02", [9, 12, 11])]:
    s = Stagiaire(nom, prenom, mat)
    for n in notes:
        s.ajouter_note(n)
    g.inscrire(s)

for p in [prof, *g.stagiaires]:
    print(p)
print("Moyenne du groupe", g.code, ":", g.moyenne())

Entrées pour input(), séparées par des virgules

Console

Mémoire : objets créés

Exécutez le code : les objets et leurs attributs s'afficheront ici.

4Pratiquer

Exercice 1 · Le meilleur stagiaire

Ajoutez à Groupe une méthode meilleur() qui renvoie le stagiaire qui a la meilleure moyenne.

Voir le corrigé

def meilleur(self):
    return max(self.stagiaires, key=lambda s: s.moyenne)

Exercice 2 · Découper en package

Proposez la structure de fichiers d'un package centre qui contient ce projet, et écrivez la ligne d'import de main.py.

Voir le corrigé

centre/
├── __init__.py        (peut être vide)
├── personnes.py       Personne, Stagiaire, Formateur
└── groupes.py         Groupe (importe Stagiaire)
main.py

# main.py
from centre.personnes import Stagiaire, Formateur
from centre.groupes import Groupe

Exercice 3 · Une nouvelle sorte de personne

Ajoutez une classe Administratif(Personne) avec un attribut poste. Que devez-vous obligatoirement écrire dans cette classe, et pourquoi ?

Voir le corrigé

class Administratif(Personne):
    def __init__(self, nom, prenom, poste):
        super().__init__(nom, prenom)
        self.poste = poste

    def fiche(self):          # obligatoire : méthode abstraite
        return f"[Admin] {self.prenom} {self.nom}, {self.poste}"

Coder une solution orientée objet complète

1Situer

2Comprendre

1. Concevoir les classes

2. Organiser en package

3. Intégrer les concepts

4. Tester au fur et à mesure

Ranger sa chambre

D'abord le schéma, ensuite le code

3Manipuler

4Pratiquer

Exercice 1 · Le meilleur stagiaire

Exercice 2 · Découper en package

Exercice 3 · Une nouvelle sorte de personne

5Vérifier