Exercices sur la programmation orientée objet

Exercice 1. QCM d’activation

Pour chaque question, une seule réponse est correcte.

Question 1. On considère le code suivant :

class Chien:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

rex = Chien("Rex", 5)

Dans ce code, rex est :

• A) une classe
• B) un attribut
• C) une instance (objet)
• D) une méthode

Question 2. Quel est le rôle du paramètre self dans une méthode ?

• A) C’est un mot-clé obligatoire de Python
• B) Il fait référence à la classe elle-même
• C) Il fait référence à l’objet sur lequel la méthode est appelée
• D) Il contient la valeur de retour de la méthode

Question 3. On considère :

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 7)

Que vaut p.x + p.y ?

• A) une erreur car on ne peut pas additionner des attributs
• B) (3, 7)
• C) 10
• D) "37"

Question 4. Que se passe-t-il si on oublie self dans la définition d’une méthode ?

class Voiture:
    def __init__(self, marque):
        self.marque = marque

    def klaxonner():     # self oublié
        return "Bip !"

v = Voiture("Renault")
v.klaxonner()

• A) La méthode affiche "Bip !"
• B) Python lève une erreur TypeError
• C) La méthode retourne None
• D) Python ignore le self manquant

Question 5. Quelle méthode spéciale faut-il définir pour que print(obj) affiche une représentation lisible d’un objet ?

• A) __init__
• B) __add__
• C) __repr__
• D) __eq__

Exercice 2. Classe Rectangle (guidé)

On souhaite créer une classe Rectangle pour représenter des rectangles géométriques.

Partie A. Compléter le code suivant :

class Rectangle:
    def __init__(self, longueur, largeur):
        self.________ = longueur
        self.________ = largeur

    def perimetre(self):
        return ________________________

    def surface(self):
        return ________________________

    def __repr__(self):
        return f"Rectangle({self.longueur}, {self.largeur})"

Partie B. Tester la classe en créant un rectangle de longueur 7 et de largeur 5, puis en affichant son périmètre et sa surface.

Partie C (enrichissement). L’héritage permet de créer une classe fille qui hérite des attributs et méthodes d’une classe mère.

Créer une classe Parallelepipede qui hérite de Rectangle et possède en plus un attribut hauteur et une méthode volume(). Le constructeur devra appeler celui de Rectangle avec Rectangle.__init__(self, longueur, largeur).

class Rectangle:
    def __init__(self, longueur, largeur):
        self.longueur = longueur
        self.largeur = largeur

    def perimetre(self):
        return 2 * (self.longueur + self.largeur)

    def surface(self):
        return self.longueur * self.largeur

    def __repr__(self):
        return f"Rectangle({self.longueur}, {self.largeur})"

r = Rectangle(7, 5)
print(r)             # Rectangle(7, 5)
print(r.perimetre()) # 24
print(r.surface())   # 35

class Parallelepipede(Rectangle):
    def __init__(self, longueur, largeur, hauteur):
        Rectangle.__init__(self, longueur, largeur)
        self.hauteur = hauteur

    def volume(self):
        return self.longueur * self.largeur * self.hauteur

p = Parallelepipede(7, 5, 2)
print(p.perimetre()) # 24 (méthode héritée de Rectangle)
print(p.volume())    # 70

Exercice 3. Classe Compte bancaire (guidé)

On souhaite modéliser un compte bancaire par une classe CompteBancaire.

1. Écrire le constructeur __init__ qui prend en paramètres numero_compte (entier), nom (chaîne du propriétaire) et solde (nombre), et les stocke comme attributs d’instance.

2. Écrire une méthode versement(montant) qui ajoute montant au solde.

3. Écrire une méthode retrait(montant) qui retire montant du solde.

4. Écrire une méthode agios() qui applique des agios de 5 % : le solde est multiplié par 0.95.

5. Écrire une méthode __repr__ qui retourne une chaîne de la forme "Compte n°1234 (Marcel) : 300 euros".

6. Tester la classe avec le scénario suivant : créer un compte n°1234 pour Marcel avec un solde de 300 euros, effectuer un retrait de 500 euros, un versement de 2000 euros, puis appliquer les agios. Afficher le compte après chaque opération.

class CompteBancaire:

    def __init__(self, numero_compte, nom, solde):
        self.numero = numero_compte
        self.nom = nom
        self.solde = solde

    def versement(self, montant):
        self.solde += montant

    def retrait(self, montant):
        self.solde -= montant

    def agios(self):
        self.solde = self.solde * 0.95

    def __repr__(self):
        return f"Compte n°{self.numero} ({self.nom}) : {self.solde} euros"

c = CompteBancaire(1234, "Marcel", 300)
print(c)  # Compte n°1234 (Marcel) : 300 euros

c.retrait(500)
print(c)  # Compte n°1234 (Marcel) : -200 euros

c.versement(2000)
print(c)  # Compte n°1234 (Marcel) : 1800 euros

c.agios()
print(c)  # Compte n°1234 (Marcel) : 1710.0 euros

Exercice 4. Classe Cercle

On souhaite modéliser un cercle $C(O, r)$ de centre $O(a, b)$ et de rayon $r$.

1. Définir une classe Cercle avec un constructeur prenant en paramètres les coordonnées a, b du centre et le rayon r.

2. Écrire une méthode surface() qui retourne la surface du cercle ($\pi r^2$). On importera pi depuis le module math.

3. Écrire une méthode perimetre() qui retourne le périmètre du cercle ($2\pi r$).

4. Écrire une méthode contient(x, y) qui retourne True si le point $A(x, y)$ est situé à l’intérieur du cercle (c’est-à-dire si $\sqrt{(x - a)^2 + (y - b)^2} \leqslant r$), et False sinon.

5. Tester avec le cercle $C$ de centre $(1, 2)$ et de rayon $3$. Le point $(2, 3)$ est-il à l’intérieur ? Et le point $(5, 5)$ ?

from math import pi, sqrt

class Cercle:
    def __init__(self, a, b, r):
        self.a = a
        self.b = b
        self.r = r

    def surface(self):
        return pi * self.r ** 2

    def perimetre(self):
        return 2 * pi * self.r

    def contient(self, x, y):
        distance = sqrt((x - self.a) ** 2 + (y - self.b) ** 2)
        return distance <= self.r

    def __repr__(self):
        return f"Cercle(centre=({self.a}, {self.b}), rayon={self.r})"

c = Cercle(1, 2, 3)
print(c.surface())       # 28.274333882308138
print(c.perimetre())     # 18.84955592153876
print(c.contient(2, 3))  # True
print(c.contient(5, 5))  # False

Exercice 5. Classe Chronomètre

On souhaite créer une classe Chronometre représentant un temps en heures, minutes et secondes.

1. Écrire le constructeur prenant en paramètres h, m et s (avec des valeurs par défaut à 0).

2. Écrire la méthode __repr__ qui retourne le temps au format "02h15m30s" (chaque valeur sur deux chiffres).

   Aide : l’expression f"{valeur:02d}" formate un entier sur deux chiffres avec un zéro initial si nécessaire.

3. Écrire une méthode en_secondes() qui retourne le temps total converti en secondes.

4. Écrire une méthode avancer(s) qui ajoute s secondes au chronomètre. Le chronomètre devra gérer les dépassements (60 secondes = 1 minute, 60 minutes = 1 heure).

   Aide : on peut convertir le temps total en secondes, ajouter s, puis reconvertir avec des divisions entières // et des modulos %.

5. Écrire la méthode __add__ pour pouvoir additionner deux chronomètres avec l’opérateur +.

6. Tester : créer un chronomètre à 1h45m50s, avancer de 75 secondes, puis additionner avec un chronomètre à 0h30m20s.

class Chronometre:
    def __init__(self, h=0, m=0, s=0):
        self.h = h
        self.m = m
        self.s = s

    def __repr__(self):
        return f"{self.h:02d}h{self.m:02d}m{self.s:02d}s"

    def en_secondes(self):
        return self.h * 3600 + self.m * 60 + self.s

    def avancer(self, s):
        total = self.en_secondes() + s
        self.h = total // 3600
        self.m = (total % 3600) // 60
        self.s = total % 60

    def __add__(self, other):
        total = self.en_secondes() + other.en_secondes()
        h = total // 3600
        m = (total % 3600) // 60
        s = total % 60
        return Chronometre(h, m, s)

c1 = Chronometre(1, 45, 50)
print(c1)            # 01h45m50s

c1.avancer(75)
print(c1)            # 01h47m05s

c2 = Chronometre(0, 30, 20)
c3 = c1 + c2
print(c3)            # 02h17m25s

Exercice 6. Classe myString (synthèse)

Les chaînes de caractères Python (str) sont immuables : on ne peut pas les modifier après création. On souhaite créer une classe myString qui encapsule une chaîne et lui ajoute des méthodes de modification similaires à celles des listes.

1. Écrire le constructeur qui prend une chaîne en paramètre et la stocke dans un attribut s.

2. Écrire la méthode __repr__ qui retourne la chaîne stockée entourée de guillemets simples, par exemple 'hello'.

3. Écrire une méthode append(texte) qui concatène texte à la fin de la chaîne stockée. La méthode ne retourne rien (elle modifie l’objet).

4. Écrire une méthode pop(i) qui supprime le caractère à l’indice i et renvoie ce caractère (comme list.pop).

   Aide : on peut reconstruire la chaîne par concaténation de la partie avant l’indice et de la partie après l’indice.

5. Écrire une méthode __len__ pour que len(obj) retourne la longueur de la chaîne stockée.

6. Écrire une méthode __eq__ pour pouvoir comparer deux objets myString avec ==.

7. Tester :

s1 = myString("hello")
s1.append(" world")
print(s1)             # 'hello world'
print(len(s1))        # 11
s1.pop(5)
print(s1)             # 'helloworld'
s2 = myString("helloworld")
print(s1 == s2)       # True

class myString:
    def __init__(self, s):
        self.s = s

    def __repr__(self):
        return f"'{self.s}'"

    def append(self, texte):
        self.s = self.s + texte

    def pop(self, i):
        caractere = self.s[i]
        self.s = self.s[:i] + self.s[i + 1:]
        return caractere

    def __len__(self):
        return len(self.s)

    def __eq__(self, other):
        if isinstance(other, myString):
            return self.s == other.s
        return False

s1 = myString("hello")
s1.append(" world")
print(s1)             # 'hello world'
print(len(s1))        # 11

c = s1.pop(5)
print(c)              # ' ' (le caractère à l'indice 5 est l'espace)
print(s1)             # 'helloworld'

s2 = myString("helloworld")
print(s1 == s2)       # True