Projet POO en python
Exercice 1 : Classe Compte Bancaire
Objectif de l’exercice
L'objectif de cet exercice est d'appliquer les bases de la programmation orientée objet (POO) en Python à travers une
classe qui gère un compte bancaire. On va définir une classe, créer des méthodes pour déposer, retirer de l'argent, et
afficher les infos du compte, avec des améliorations progressives.
1. Créer une classe Python CompteBancaire qui représente un compte bancaire, qui a comme attributs :
numero, nom, solde, type de compte (épargne, courant).
Code
Explication : on définit la classe avec ses attributs principaux : le numéro du compte, le nom du titulaire, le solde
initial, et le type de compte ("épargne" ou "courant").
2. Créer un constructeur ayant comme paramètres les attributs de cette classe.
Le constructeur est déjà inclus dans la définition précédente. Il permet de créer un objet CompteBancaire avec les
informations passées en paramètre.
3. Développer une méthode versement () qui gère les versements.
Code
Explication : cette méthode permet d'ajouter de l'argent au solde si le montant est valide.
4. Créer une méthode retraite () qui gère les retraits. Il faut prendre en considération le cas où le solde
est insuffisant.
Code
Explication : on vérifie que le montant est positif et que le solde est suffisant avant de retirer
5. Créer une méthode interets() permettant d'appliquer les intérêts de 5 % au solde en fonction de type
de compte et le nombre d’années appliquées.
Code
Explication : si le compte est un compte épargne, on applique un taux de 5 % par année. Sinon, on affiche un
message.
6. Créer une méthode afficher () permettant d’afficher les détails sur le compte.
Code
Explication : affiche toutes les informations du compte de façon lisible.
7. Proposer une méthode permettant de changer le type de compte.
Code
Explication : on vérifie que le nouveau type est valide avant de faire le changement.
8. Créer une classe de test permettant de créer un objet de cette classe et tester les différentes méthodes.
Code
Conclusion
Cet exercice permet de comprendre comment modéliser un vrai système bancaire simple en Python avec des classes.
On applique toutes les notions essentielles de la POO : attributs, constructeurs, méthodes, conditions, et tests. Le fait
de distinguer les types de comptes et d’ajouter des intérêts rend l’exercice plus réaliste et complet.
Exercice 2 : Classe Personne
Objectif de l’exercice
Cet exercice a pour but de modéliser une personne avec ses caractéristiques, et de manipuler ces données grâce à la
POO. On y ajoute également un traitement d'adresse sous forme de classe, ainsi que le calcul et l'interprétation de
l'IMC.
Question 1 et 2
1. Soit une classe Personne ayant des attributs définissant certaines caractéristiques d’une personne réelle : CIN,
nom, prenom, adresse, taille, poids et age.
2. Définir le contenu de la méthode init (constructeur) qui permet d’initialiser les attributs de cette classe.
Code
Explication
En Python, une classe sert à modéliser un objet. Ici, on veut représenter une personne réelle avec certaines
informations. Pour cela, on utilise le mot-clé class.
Le constructeur __init__ est une méthode spéciale qui s'exécute automatiquement lorsqu'on crée un objet. Il permet de
donner une valeur initiale à chaque attribut.
Question 3 et 4
1. Développer des méthodes permettant d’afficher les informations d’une personne une par une
2. Proposer une méthode permettant d’afficher toutes les informations d’une personne.
Code
Explication
Une méthode d’affichage individuelle est utile quand on veut voir une seule info (par exemple le CIN).
La méthode d’affichage globale est un raccourci pour tout voir sans les appeler une par une.
Question 5 et 6
1. Cette classe aura une méthode IMC() qui détermine l’IMC (poids/taille²) de la personne.
2. Développer une méthode interpretation() qui affiche "Insuffisance pondérale" si l’IMC est inférieur ou égale à
18,5 et qui affiche "obésité" si l’IMC est supérieur ou égale à 30.
Code
Explication
L’IMC (Indice de Masse Corporelle) est une formule médicale :
𝑝𝑜𝑖𝑑𝑠
IMC= 𝑡𝑎𝑖𝑙𝑙𝑒
L’interprétation médicale est simple :
• IMC ≤ 18.5 → Insuffisance pondérale
• IMC ≥ 30 → Obésité
• Sinon → IMC normal
7. Développer une classe de teste permettant de créer un objet de la classe Personne.
a. Instancier un objet de la classe Personne.
b. Invoquer la méthode permettant d’afficher le CIN d’une personne.
c. Modifier l’adresse de cet objet. Afficher les résultats de la modification.
d. Afficher toutes les informations de cet objet.
e. Appeler la méthode IMC pour obtenir l’IMC de cette personne.
f. Appeler la méthode interpretation() pour afficher l’interprétation en fonction de IMC.
Code
Question 8 et 9
1. Au début de cet exercice, nous avons défini l’adresse comme chaine de caractères. Modifier le programme de
tel manière que l’adresse sera une classe définie par les attributs suivants : numero, rue, boulevard, code postal
et ville.
2. Importer les modifications nécessaires au programme.
Code
Question 10
Code
Conclusion
En réalisant cet exercice, j’ai compris concrètement comment modéliser un objet du monde réel (ici, une
personne) en programmation orientée objet.
J’ai appris à :
• Créer une classe avec un constructeur __init__ qui initialise plusieurs attributs d’un coup.
• Définir des méthodes pour accéder et afficher les données : une par une ou toutes à la fois.
• Calculer une valeur à partir des attributs (comme l’IMC) et en tirer une interprétation logique.
• Mettre à jour dynamiquement une information comme l’adresse, ce qui m’a permis de comprendre
l’utilité d’encapsulation et de structuration avec une classe imbriquée (Adresse).
• Enfin, j’ai testé mon code avec des cas concrets, ce qui m’a vraiment permis de valider mes
méthodes et corriger des erreurs logiques.
J’ai aussi compris l’intérêt de créer une classe Adresse à part, car elle rend le code plus clair, mieux
organisé et plus proche de la réalité.
Exercice 3 : Classe Calcul
1. Créer une classe Calcul ayant un constructeur par défaut (sans paramètres) permettant d’effectuer différents
calculs sur les nombres entiers.
2. Créer les méthodes permettant de calculer et retourner la somme, le produit et la moyenne des n premiers entiers:
1 + 2 + 3 + .. + n.
Code
Explication
Je crée une classe nommée Calcul, sans attribut particulier. Elle sert juste à regrouper des méthodes utiles de
mathématiques.
Le constructeur n’a pas besoin de faire grand-chose. Ensuite, je vais coder :
• somme(n) → la somme des n premiers entiers
• produit(n) → le produit des n premiers entiers
• moyenne(n) → la moyenne de ces n nombres
3. Créer au sein de la classe Calcul une méthode nommée factorielle() qui permet de calculer le factorielle d’un
entier.
4. Développer une méthode nommée test_primalite() permettant de tester la primalité d’un entier donné.
Code
Explication
• La factorielle est comme un produit, mais d’un seul nombre : 5! = 1×2×3×4×5.
• La primalité, c’est vérifier si un entier est premier, c’est-à-dire divisible seulement par 1 et lui-même.
5. Implémenter une méthode nommée test_premier() permettant de tester si deux nombres sont premier entre eux.
6. Créer une méthode table_multiplication() qui crée et affiche la table de multiplication d’un entier donné.
Code
Explication
• Deux nombres sont premiers entre eux s’ils n’ont aucun diviseur commun sauf 1 → PGCD = 1
• La table de multiplication est juste une boucle qui affiche n * i pour i de 1 à 10.
7. Créer une méthode list_diviseurs() qui récupère tous les diviseurs d’un entier donné sur une liste list_div.
8. Créer une autre méthode list_diviseurs_premiers() qui récupère tous les diviseurs premiers d’un entier donné.
Code
Explication
• Les diviseurs d’un nombre sont ceux qui le divisent sans reste.
• Les diviseurs premiers sont les diviseurs qui sont aussi des nombres premiers.
Conclusion
En créant cette classe Calcul, j’ai pu revoir plusieurs notions importantes de mathématiques : somme, moyenne,
factorielle, primalité, optimalité, et diviseurs.
J’ai aussi amélioré ma logique de programmation avec des boucles, des fonctions imbriquées (comme le PGCD), et
des listes par compréhension.
L’exercice m’a aidé à créer un outil pratique pour automatiser des calculs souvent faits à la main.
Si je voulais aller plus loin, je pourrais ajouter une interface ou sauvegarder les résultats dans un fichier.
Exercice 4
1. Ecrire une classe Forme Géométrique en langage Python, permettant de construire une forme géométrique
définie par le nom de la forme, l’abscisse, l’ordonné, surface, périmètre.
2. Définir une méthode perimetre() permettant de calculer le périmètre d’une forme géométrique.
Code
Explication
Dans cette première étape, on définit une classe de base générique pour toutes les formes. Elle contient :
• le nom de la forme (ex. "Rectangle", "Cercle"),
• ses coordonnées (abscisse x et ordonnée y),
• la surface et le périmètre (qu’on initialise à 0),
• des getters et setters (encapsulation),
• des méthodes vides perimetre() et surface() qui seront redéfinies dans les classes filles.
3. Définir une méthode surface() permettant de calculer la surface de cette forme.
4. Implémenter les modificateurs d’accès de cette classe.
Code
Explication
• Le Rectangle a une longueur L et une largeur l.
o Périmètre = 2(L + l)
o Surface = L × l
• Le Cercle a un rayon r.
o Périmètre = 2πr
o Surface = πr²
5. réer trois classes Rectangle, Cercle et Triangle (voir TD1) qui héritent de la classe FormeGeometrique.
6. Redéfinir les méthodes perimetre() et surface() pour chaque classe.
Code
Explication
Le triangle est défini ici par la longueur de ses trois côtés a, b, c.
• Périmètre = a + b + c
• Surface : On utilise la formule de Héron :
𝑎+𝑏+𝑐
𝑠= , surface =√𝑠(𝑠 − 𝑎)(𝑠 − 𝑏)(𝑠 − 𝑐)
2
7. Développer une classe de test permettant de créer un objet de chacune de ces classes et tester les différentes
méthodes.
Code
Explication
On crée une classe TestFormes dans laquelle :
• on instancie un Rectangle, un Cercle et un Triangle,
• on affiche les résultats des méthodes surface() et perimetre() pour chaque objet.
8. Proposé une classe Cube qui hérite de la classe Rectangle. Ajouter les attributs et les méthodes convenables
:
a) Le périmètre P = (longueur + largeur) × 2
b) surface vaut 2ℎl+2hl+2Ll ;
c) Le volume vaut Llh ;
d) La longueur d'une diagonale vaut √𝐿2 + ℎ2 + 𝑙 2
9. Redéfinir les méthodes permettant de traiter le cas d’un cube.
Code
Explication
Un Cube (en réalité ici un parallélépipède rectangle) est défini par :
• Longueur L (héritée du Rectangle),
• Largeur l (héritée aussi),
10. Dans la même classe de test, créer un objet de cette classe et tester les différentes méthodes ainsi
implémentées.
Code
Explication
On ajoute à la classe TestFormes un test du Cube :
• on affiche la surface, le périmètre, le volume, et la diagonale.
11. Proposer une structuration du code via la manipulation de la notion de module(package).
Code
Conclusion
Cet exercice nous a permis de passer de la simple définition de classes à une vraie conception objet propre,
réutilisable, et organisée. C’est exactement la manière de faire dans des projets plus complexes ou professionnels.
Fait par : BOLEMBO BONYONGA Alenick Christian
