Exercices : 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 Parallelepipede(Rectangle):
    def __init__(self, longueur, largeur, hauteur):
        Rectangle.__init__(self, ..., ...)
        self.hauteur = ...

    def volume(self):
        return ...

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.

   Indice

   Un attribut par paramètre, créé avec self. : par exemple self.solde = solde.

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

   Indice

   La méthode modifie l’attribut du solde : self.solde = self.solde + montant. Elle ne renvoie rien.

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

   Indice

   Même principe que versement, avec une soustraction.

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

   Indice

   Multiplier self.solde par 0.95 et ranger le résultat dans self.solde.

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

   Indice

   __repr__ renvoie une f-string construite avec les attributs du compte, sur le modèle f"Compte n°{...} ({...}) : {...} 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.

   Indice

   Créer le compte avec CompteBancaire(1234, "Marcel", 300), puis appeler chaque méthode et afficher le compte avec print après chaque opération : print utilise __repr__.

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.

   Indice

   Trois attributs, un par paramètre : self.a, self.b et self.r.

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

   Indice

   Écrire from math import pi en haut du programme, puis traduire la formule avec l’attribut du rayon, self.r. Le carré s’écrit ** 2.

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.

   Indice

   Calculer la distance entre le point et le centre avec sqrt (à importer aussi depuis math), puis renvoyer directement le résultat de la comparaison distance <= self.r, qui vaut True ou False.

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)$ ?

   Indice

   Créer c = Cercle(1, 2, 3), puis afficher c.contient(2, 3) et c.contient(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).

   Indice

   Les valeurs par défaut s’écrivent dans la ligne de définition : def __init__(self, h=0, m=0, s=0):. Ranger ensuite chaque paramètre dans un attribut.

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.

   Indice

   Une heure vaut 3600 secondes et une minute 60 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 %.

   Code à copier puis compléter

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

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

   Indice

   __add__(self, other) reçoit le second chronomètre. Additionner les deux temps en secondes, convertir le total en heures, minutes et secondes comme dans avancer, puis construire et renvoyer un nouveau Chronometre : les deux chronomètres de départ ne changent pas.

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

   Indice

   c1 = Chronometre(1, 45, 50), puis c1.avancer(75) ; l’expression c1 + Chronometre(0, 30, 20) appelle __add__. Afficher le résultat avec print.

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'.

   Indice

   __repr__ renvoie une chaîne : construire une f-string qui place self.s entre deux guillemets simples.

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).

   Indice

   Concaténer avec + et ranger le résultat dans self.s.

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.

   Code à copier puis compléter

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

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

   Indice

   len(obj) appelle obj.__len__() : renvoyer la longueur de la chaîne stockée dans l’attribut.

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

   Indice

   __eq__(self, other) reçoit l’objet comparé : deux myString sont égaux lorsque leurs attributs s sont égaux.

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