Aller au contenu

Exercices de POO - série 2

Crédits⚓︎

Ces exercices ont été créés par Gilles Lassus et publiés sous licence cc nc-by-sa

Exercices⚓︎

Exercice 1

  1. Écrire une classe Eleve qui contiendra les attributs nom, classe et note.
  2. Instancier trois élèves de cette classe.
  3. Écrire une fonction compare(eleve1, eleve2) qui renvoie le nom de l'élève ayant la meilleure note.
Exemple d'utilisation de la classe
Python
>>> riri = Eleve("Henri", "TG2", 12)
>>> fifi = Eleve("Philippe", "TG6", 15)
>>> loulou = Eleve("Louis", "TG1", 8)
>>> compare(riri, fifi)
'Philippe'
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Eleve:
    def __init__(self, nom, classe, note):
        self.nom = nom
        self.classe = classe
        self.note = note

def compare(eleve1, eleve2):
    if eleve1.note > eleve2.note:
        return eleve1.nom
    else:
        return eleve2.nom

Exercice 2

Écrire une classe TriangleRect qui contiendra les attributs cote1, cote2 et hypotenuse.

La méthode constructeur ne prendra en paramètres que cote1 et cote2, l'attribut hypotenuse se calculera automatiquement.

⚠️ Attention, hypotenuse n'est pas une méthode.

Exemple d'utilisation de la classe
Python
>>> mon_triangle = TriangleRect(3,4)
>>> mon_triangle.cote1
3
>>> mon_triangle.cote2
4
>>> mon_triangle.hypotenuse
5.0

###(Dés-)Active le code après la ligne # Tests (insensible à la casse)
(Ctrl+I)
Entrer ou sortir du mode "deux colonnes"
(Alt+: ; Ctrl pour inverser les colonnes)
Entrer ou sortir du mode "plein écran"
(Esc)
Tronquer ou non le feedback dans les terminaux (sortie standard & stacktrace / relancer le code pour appliquer)
Si activé, le texte copié dans le terminal est joint sur une seule ligne avant d'être copié dans le presse-papier
Évaluations restantes : 4/4

.128013g: r;)S/q(.`loy,1=acx+udt2_P?vep-fh*TOmnRis050G040D0V0d0z0Q0G0d010h0o0n0x0Y0o0O01050i0T06050y0Q0E0d0u0n0t0R0R0s010|0O0b0x0t0b0F0H0z0F0v0z0d0J0Q0b0J0n1g0J0z0104050R0G0t0O0`0|0~100I0Q0n0F0O0t0N0F1n0L1b1d0M0O0n0p0/1q1s1o0G0e0F1o1P0O1o0i1W1o0u0o0y1U0d020n0z0f0G020b1-1+1-0:1:1-06060d0m1~0G0p0z0J0,0X0Q0z1A0s020j0x0o1-0a0d0C0e0o0G0o0R260Q241(0`0o0e1T0u0+0O2a2c1-0d1j0O1B0x0N0 2y2d0f0r2I1`0d0I2i0N0d0N0t220d0Q0N2k0e1d0R0j2!1{1u0}0R0d0L0e0Q1s0b1A0P0F2v0c1|0d2|0d1(0I0d0B0B0Q0O26320k0R0F0n0I0q2r1a0r3d1$1a0A0g2`2}3n2|393b0l3i0F0r0d0s3e3u2{3o3p3a0I3s2d0F0A3w3y0A3A3B3q3E0J0p2k1a0O0x393J2$2!0k3t0r0K0K3I0w3K3%3k1|1~0m0=0i1$1(1Y1S1U0/0@0E04.

Exercice 3

  1. Écrire une classe Chrono qui contiendra les attributs heures, minutes et secondes.
  2. Doter la classe d'une méthode affiche() qui fera affichera le temps t.
  3. Doter la classe d'une méthode avance(s) qui fera avancer le temps t de s secondes.
Exemple d'utilisation de la classe
Python
>>> t = Chrono(17,25,38)
>>> t.heures
17
>>> t.minutes
25
>>> t.secondes
38
>>> t.affiche()
'Il est 17 heures, 25 minutes et 38 secondes'
>>> t.avance(27)
>>> t.affiche()
'Il est 17 heures, 26 minutes et 5 secondes'
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Chrono:
    def __init__(self, h, m, s):
        self.heures = h
        self.minutes = m
        self.secondes = s

    def affiche(self):
        return "Il est "+ str(self.heures) + " heures " + str(self.minutes) + \
    " minutes et " + str(self.secondes) + " secondes."

    def avance(self, s):
        self.secondes = self.secondes + s
        # il faut ajouter les minutes supplémentaires si les secondes dépassent 60
        self.minutes = self.minutes + self.secondes // 60
        # il ne faut garder des secondes que ce qui n'a pas servi
        # à fabriquer des minutes supplémentaires
        self.secondes = self.secondes % 60
        # il faut ajouter les heures supplémentaires si les minutes dépassent 60
        self.heures = self.heures + self.minutes // 60
        # il ne faut garder des minutes que ce qui n'a pas servi
        # à fabriquer des heures supplémentaires
        self.minutes = self.minutes % 60

Exercice 4

Écrire une classe Player qui :

  • ne prendra aucun argument lors de son instanciation.
  • affectera à chaque objet créé un attribut energie valant 3 par défaut.
  • affectera à chaque objet créé un attribut alive valant True par défaut.
  • fournira à chaque objet une méthode blessure() qui diminue l'attribut energie de 1.
  • fournira à chaque objet une méthode soin() qui augmente l'attribut energie de 1.
  • si l'attribut energie passe à 0, l'attribut alive doit passer à False et ne doit plus pouvoir évoluer.
Exemple d'utilisation de la classe
Python
>>> mario = Player()
>>> mario.energie
3
>>> mario.soin()
>>> mario.energie
4
>>> mario.blessure()
>>> mario.blessure()
>>> mario.blessure()
>>> mario.alive
True
>>> mario.blessure()
>>> mario.alive
False
>>> mario.soin()
>>> mario.alive
False
>>> mario.energie
0
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Player:
    def __init__(self):
        self.energie = 3
        self.alive = True

    def blessure(self):
        self.energie -= 1
        if self.energie <= 0:
            self.alive = False

    def soin(self):
        if self.energie > 0:
            self.energie += 1

Exercice 5

Créer une classe CompteBancaire dont la méthode constructeur recevra en paramètres :

  • un attribut titulaire stockant le nom du propriétaire.
  • un attribut solde contenant le solde disponible sur le compte.

Cette classe contiendra deux méthodes retrait() et depot() qui permettront de retirer ou de déposer de l'argent sur le compte.

Exemple d'utilisation de la classe
Python
>>> compteGL = CompteBancaire("G.Lassus", 1000)
>>> compteGL.retrait(50)
Vous avez retiré 50 euros
Solde actuel du compte : 950 euros
>>> compteGL.retrait(40000)
Retrait impossible
>>> compteGL.depot(10000000)
Vous avez déposé 10000000 euros
Solde actuel du compte : 10000950 euros
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class CompteBancaire:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.solde = solde

    def retrait(self, somme):
        if somme > self.solde:
            print("Retrait impossible")
        else :
            self.solde -= somme
            print("Vous avez retiré ", somme, " euros.")
            print("Solde actuel du compte : ", self.solde, " euros.")
    def depot(self, somme):
        self.solde += somme
        print("Vous avez déposé ", somme, " euros.")
        print("Solde actuel du compte : ", self.solde, " euros.")

Exercice 6

Cet exercice est l'exercice 5.2 de la BNS (version 2022) légèrement modifié.

On dispose d’un programme permettant de créer un objet de type PaquetDeCarte, selon les éléments indiqués dans le code ci-dessous. Compléter ce code aux endroits indiqués par ..., puis ajouter des assertions dans l’initialiseur de Carte, ainsi que dans la méthode getCarteAt().

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Carte:

    def __init__(self, c, v):
        """Initialise Couleur (entre 1 a 4), et Valeur (entre 1 a 13)"""
        self.Couleur = c
        self.Valeur = v

    def getNom(self):
        """Renvoie le nom de la Carte As, 2, ... 10, Valet, Dame, Roi"""
        if ( self.Valeur > 1 and self.Valeur < 11):
            return str( self.Valeur)
        elif self.Valeur == 11:
            return "Valet"
        elif self.Valeur == 12:
            return "Dame"
        elif self.Valeur == 13:
            return "Roi"
        else:
            return "As"

    def getCouleur(self):
        """Renvoie la couleur de la Carte (parmi pique, coeur, carreau, trefle"""
        return ['pique', 'coeur', 'carreau', 'trefle' ][self.Couleur - 1]

class PaquetDeCarte:

    def __init__(self):
        self.contenu = []

    def remplir(self):
        """Remplit le paquet de cartes"""
        ... = [ ... for couleur in range(1, ...) for valeur in range( 1, ...)]

    def getCarteAt(self, pos):
        """Renvoie la Carte qui se trouve a  la position donnee"""
        if 0 <= pos < ... :
            return ...

👉 Exemple :

Python
>>> unPaquet = PaquetDeCarte()
>>> unPaquet.remplir()
>>> uneCarte = unPaquet.getCarteAt(20)
>>> print(uneCarte.getNom() + " de " + uneCarte.getCouleur())
8 de coeur
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Carte:

    def __init__(self, c, v):
        """Initialise Couleur (entre 1 à 4), et Valeur (entre 1 à 13)"""
        assert c in range(1,5)
        assert v in range(1,14)
        self.Couleur = c
        self.Valeur = v

    def getNom(self):
        """Renvoie le nom de la Carte As, 2, ... 10, Valet, Dame, Roi"""
        if (self.Valeur > 1 and self.Valeur < 11):
            return str( self.Valeur)
        elif self.Valeur == 11:
            return "Valet"
        elif self.Valeur == 12:
            return "Dame"
        elif self.Valeur == 13:
            return "Roi"
        else:
            return "As"

    def getCouleur(self):
        """Renvoie la couleur de la Carte (parmi pique, coeur, carreau, trefle"""
        return ['pique', 'coeur', 'carreau', 'trefle'][self.Couleur - 1]

class PaquetDeCarte:

    def __init__(self):
        self.contenu = []

    def remplir(self):
        """Remplit le paquet de cartes"""
        self.contenu = [Carte(couleur, valeur) for couleur in range(1, 5) for valeur in range(1, 14)]

    def getCarteAt(self, pos):
        """Renvoie la Carte qui se trouve à la position donnée"""
        if 0 <= pos < len(self.contenu) :
            return self.contenu[pos]

Exercice 7 : Une bibliothèque

👉 Gestion d'une bibliothèque

Il s'agit de gérer les livres d'une bibliothèque, à l'aide de deux classes, la classe Livre et la classe Bibliotheque.

Le cahier des charges ci-dessous comporte la description des deux classes, ainsi qu'un exemple concret de leur utilisation.

👉 classe Livre Elle comporte 3 attributs :

  • titre : le titre du livre
  • auteur : le nom de l'auteur
  • etat : un nombre entier entre 0 et 5. Si l'état vaut 0, le livre est trop abîmé et doit être retiré de la bibliothèque. L'état d'un livre ne peut pas être négatif.

Elle comporte 2 méthodes : - degrade : enlève 1 à l'état du livre. - description : affiche les renseignements sur le livre

👉 classe Bibliotheque

Elle comporte 1 attribut :
- livres : une liste (vide à la création de l'objet)

Elle comporte 3 méthodes :

  • ajoute : prend un livre en paramètre et l'ajoute à la bibliothèque.
  • supprime_livres_abimes : enlève de la bibliothèque les livres trop abîmés.
  • inventaire : affiche le contenu de la bibliothèque

👉 Exemple d'utilisation des classes

Python
>>> ma_bibli = Bibliotheque()
>>> livre1 = Livre("Les Misérables", "Victor Hugo", 3)
>>> livre2 = Livre("Les fleurs du mal", "Charles Baudelaire", 1)
>>> ma_bibli.ajoute(livre1)
>>> ma_bibli.ajoute(livre2)
>>> livre1.description()
Titre : Les Misérables
Auteur : Victor Hugo
Etat : 3
>>> livre2.degrade()
>>> livre2.description()
Titre : Les fleurs du mal
Auteur : Charles Baudelaire
Etat : 0
>>> ma_bibli.inventaire()
-------------------------------
contenu de ma bibliothèque :
-------------------------------
Titre : Les Misérables
Auteur : Victor Hugo
Etat : 3
Titre : Les fleurs du mal
Auteur : Charles Baudelaire
Etat : 0
>>> ma_bibli.supprime_livres_abimes()
>>> ma_bibli.inventaire()
-------------------------------
contenu de ma bibliothèque :
-------------------------------
Titre : Les Misérables
Auteur : Victor Hugo
Etat : 3

Question

Proposer un code pour la classe Livre et la classe Bibliotheque répondant au cahier des charges.

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Livre():

    def __init__(self, titre, auteur, etat):
        self.titre = titre
        self.auteur = auteur
        self.etat = etat

    def degrade(self):
        if self.etat > 0:
            self.etat -= 1

    def description(self):
        print("Titre :", self.titre)
        print("Auteur :",self.auteur)
        print("Etat :", self.etat)

class Bibliotheque:

    def __init__(self):
        self.livres = []

    def ajoute(self, livre):
        self.livres.append(livre)

    def supprime_livres_abimes(self):
        for livre in self.livres:
            if livre.etat == 0:
                self.livres.remove(livre)

    def inventaire(self):
        print("---------------")
        print("contenu de ma bibliothèque :")
        print("---------------")
        for livre in self.livres:
            livre.description()
            print()
ma_bibli = Bibliotheque()
livre1 = Livre("Les Misérables", "Victor Hugo", 3)
livre2 = Livre("Les fleurs du mal", "Charles Baudelaire", 1)
livre1.description()
ma_bibli.ajoute(livre1)
ma_bibli.ajoute(livre2)
ma_bibli.inventaire()

Pour approfondir : Les fractions égyptiennes⚓︎

Pour le fun - travail facultatif

Si vous avez du temps ... et aimez les mathématiques ...

Après avoir téléchargé le fichier, vous pourrez le lire à partir de Basthon

🌐 TD à télécharger : Fichier Fractions_egyptiennes_POO_sujet_2022.ipynb : "Clic droit", puis "Enregistrer la cible du lien sous"

⏳ La correction viendra bientôt ... si vous la demandez à votre professeur après lui avoir montré votre travail ... 😊