← Retour aux activités

Exercices : Programmation Orientée Objet

Pratiquez les concepts fondamentaux de la POO en Python : classes, attributs, méthodes et encapsulation.

Exercice 1 : La classe Voiture

1. Définir une classe Voiture avec un constructeur initialisant les attributs marque et modele.

Utilisez le mot-clé class et la méthode spéciale __init__.
class Voiture:
  def __init__(self, marque, modele):
    self.marque = marque
    self.modele = modele

2. Ajouter un attribut vitesse initialisé à 0 par défaut dans le constructeur.

Ajoutez self.vitesse = 0 dans __init__ sans l'ajouter aux paramètres.
def __init__(self, marque, modele):
  self.marque = marque
  self.modele = modele
  self.vitesse = 0

3. Créer une méthode accelerer(self, valeur) qui augmente la vitesse.

Additionnez valeur à self.vitesse.
def accelerer(self, valeur):
  self.vitesse += valeur

4. Ajouter une méthode afficher_vitesse(self) qui affiche la vitesse actuelle.

Utilisez print() et f-string.
def afficher_vitesse(self):
  print(f"Vitesse : {self.vitesse} km/h")

5. Instancier une voiture "Peugeot 208" et la faire accélérer de 30 km/h.

ma_voiture = Voiture("Peugeot", "208")
v1 = Voiture("Peugeot", "208")
v1.accelerer(30)

Exercice 2 : Gestion d'un Compte Bancaire

1. Créer une classe CompteBancaire avec les attributs titulaire et solde.

Même structure que l'exercice 1.
class CompteBancaire:
  def __init__(self, titulaire, solde):
    self.titulaire = titulaire
    self.solde = solde

2. Ajouter une méthode deposer(self, montant).

Ajoutez le montant au solde actuel.
def deposer(self, montant):
  self.solde += montant

3. Ajouter une méthode retirer(self, montant) qui vérifie si le solde est suffisant.

Utilisez une condition if self.solde >= montant:.
def retirer(self, montant):
  if self.solde >= montant:
    self.solde -= montant
  else:
    print("Solde insuffisant")

4. Ajouter une méthode __str__ pour afficher joliment le compte.

La méthode doit retourner (return) une chaîne de caractères.
def __str__(self):
  return f"Compte de {self.titulaire} : {self.solde}€"

5. Créer un compte avec 100€, retirer 150€ et afficher le résultat.

Utilisez print(compte) pour tester __str__.
c = CompteBancaire("Alice", 100)
c.retirer(150)
print(c)

Exercice 3 : Rectangles et Périmètres

1. Créer une classe Rectangle avec longueur et largeur.

Initialisez les deux attributs dans __init__.
class Rectangle:
  def __init__(self, long, larg):
    self.longueur = long
    self.largeur = larg

2. Ajouter une méthode aire(self) qui retourne l'aire.

Aire = longueur * largeur.
def aire(self):
  return self.longueur * self.largeur

3. Ajouter une méthode perimetre(self) qui retourne le périmètre.

Périmètre = 2 * (longueur + largeur).
def perimetre(self):
  return 2 * (self.longueur + self.largeur)

4. Ajouter une méthode est_carre(self) qui retourne un booléen.

Vérifiez si self.longueur == self.largeur.
def est_carre(self):
  return self.longueur == self.largeur

5. Modifier la longueur d'un rectangle existant et recalculer l'aire.

Accédez directement à l'attribut : rect.longueur = 10.
r = Rectangle(5, 3)
r.longueur = 7
print(r.aire())

Exercice 4 : Interaction entre Objets

1. Créer une classe Robot avec un attribut nom et energie (100).

Initialisez l'énergie à 100 par défaut.
class Robot:
  def __init__(self, nom):
    self.nom = nom
    self.energie = 100

2. Ajouter une méthode saluer(self, autre_robot) qui affiche le nom de l'autre robot.

Accédez à autre_robot.nom.
def saluer(self, autre_robot):
  print(f"Bonjour {autre_robot.nom}, je suis {self.nom}")

3. Ajouter une méthode donner_energie(self, autre_robot, quantite).

Soustrayez au donneur (self) et ajoutez au receveur (autre_robot).
def donner_energie(self, autre_robot, quantite):
  if self.energie >= quantite:
    self.energie -= quantite
    autre_robot.energie += quantite

4. Créer deux robots R2D2 et C3PO et faire un transfert d'énergie.

Appelez la méthode sur l'un des deux objets.
r1 = Robot("R2D2")
r2 = Robot("C3PO")
r1.donner_energie(r2, 20)

5. Ajouter une méthode est_vivant(self) qui retourne True si énergie > 0.

Utilisez une simple comparaison.
def est_vivant(self):
  return self.energie > 0