Aller au contenu

Exercices⚓︎

Exercice 1

Q1. Écrire une classe Eleve qui contiendra les attributs nom, classe et note.

Correction 
1
2
3
4
5
class Eleve:
    def __init__(self, nom, classe, note):
        self.nom = nom
        self.classe = classe
        self.note = note

Q2. Instancier trois élèves de cette classe.

Correction 
riri = Eleve('Henri', 'TG2', 12)
fifi = Eleve('Philippe', 'TG6', 15)
loulou = Eleve('Louis', 'TG1', 8)

Q3. Écrire une fonction compare qui prend en paramètres deux élèves eleve1 et eleve2 qui renvoie le nom de l'élève ayant la meilleure note (on ne traitera pas à part le cas d'égalité).

Correction 
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

Exemple d'utilisation de la classe

>>> riri = Eleve("Henri", "TG2", 12)
>>> fifi = Eleve("Philippe", "TG6", 15)
>>> loulou = Eleve("Louis", "TG1", 8)
>>> compare(riri, fifi)
'Philippe'

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.

Exemple d'utilisation de la classe

>>> mon_triangle = TriangleRect(3,4)
>>> mon_triangle.cote1
3
>>> mon_triangle.cote2
4
>>> mon_triangle.hypotenuse
5.0
Correction 
1
2
3
4
5
class TriangleRect:
    def __init__(self, c1, c2):
        self.cote1 = c1
        self.cote2 = c2
        self.hypotenuse = (self.cote1**2 + self.cote2**2)**0.5

Exercice 3

Q1. Écrire une classe Chrono qui contiendra les attributs heures, minutes et secondes.

Correction 
class Chrono:
    def __init__(self, h, m, s):
        self.heures = h
        self.minutes = m
        self.secondes = s

Q2. Doter la classe d'une méthode affiche qui affichera le temps t.

Correction 
class Chrono:
    def __init__(self, h, m, s):
        self.heures = h
        self.minutes = m
        self.secondes = s   

def affiche(self):
    print('Il est {} heures, {} minutes et {} secondes'.format(self.heures, self.minutes, self.secondes))

Q3. Doter la classe d'une méthode avance qui prend en paramètre un temps s en secondes et qui fait avancer le temps t de s secondes.

Correction 
class Chrono:
    def __init__(self, h, m, s):
        self.heures = h
        self.minutes = m
        self.secondes = s   

def affiche(self):
    print('Il est {} heures, {} minutes et {} secondes'.format(self.heures, self.minutes, self.secondes))   

def avance(self, s):
    self.secondes += s

    # il faut ajouter les minutes supplémentaires si les secondes
    # dépassent 60
    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.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

Exemple d'utilisation de la classe

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

On pourra utiliser les opérateurs :

  • %, qui calcule le reste d'une division euclidienne.
  • //, qui calcule le quotient d'une division euclidienne.

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

>>> 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
Correction 
 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.alive:
            self.energie += 1

À faire sur Capytale : activité 2ef0-54279

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

>>> 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
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
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é {} euros'.format(somme))
            print('Solde actuel du compte : {} euros'.format(self.solde))

    def depot(self, somme):
        self.solde += somme
        print('Vous avez déposé {} euros'.format(somme))
        print('Solde actuel du compte : {} euros'.format(self.solde))

Exercice 6

Exercice 14.2 de la BNS 2024.

Exercice 7

Exercice 2 Partie A du sujet Métropole Septembre 2022

Correction Q1.a

La liste v contient 5 éléments.

Correction Q1.b

v[1].nom() renvoie Les goélands.

⚠ la classe Villa possède un attribut nom ET une méthode nom(). Ceci est affreux et provoquerait une erreur lors de l'appel à la méthode nom().

Correction Q1.c 
def surface(self):
    return self.sejour.sup + self.ch1.sup + self.ch2.sup
Correction Q2 
for villa in v:
    if villa.eqCuis == 'eq':
        print(villa.nom)

ou bien

for villa in v:
    if villa.equip() == 'eq':
        print(villa.nom)

Exercice 8

Exercice 5 du sujet Métropole J1 2022

Correction Q1

Instruction 3 : joueur1 = Joueur('Sniper', 319, 'A')

Correction Q2.a 

1
2
3
def redevenir_actif(self):
    if self.est_actif == False:
        self.est_actif = True
ou mieux : 
1
2
3
def redevenir_actif(self):
    if not self.est_actif:
        self.est_actif = True

Correction Q2.b 
1
2
def nb_tirs_recus(self):
    return len(self.liste_id_tirs_recus)
Correction

Le test est le test 1.

Correction Q3.b

Si un joueur a été touché par un tir allié, son score diminue de 20 points.

Correction Q4 

1
2
if participant.est_determine() == True:
    self.incremente_score(40)
ou mieux : 
1
2
if participant.est_determine():
    self.incremente_score(40)

Exercice 9

Exercice 2 du sujet La Réunion J1 2022

Correction Q1.a 
1
2
3
4
i = 0
while i < len(Mousse) and Mousse[i] != None:
    i += 1
return i
Correction Q1.b 
1
2
3
4
def placeBulle(B):
    i = donnePremierIndiceLibre(Mousse)
    if i != 6:
        Mousse[i] = B
Correction Q2 
1
2
def bullesEnContact(B1,B2):
    return distanceEntreBulles(B1, B2) <= B1.rayon + B2.rayon
Correction Q3 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def collision(indPetite, indGrosse, Mousse) :
    """
    Absorption de la plus petite bulle d’indice indPetite
    par la plus grosse bulle d’indice indGrosse. Aucun test
    n’est réalisé sur les positions.
    """
    # calcul du nouveau rayon de la grosse bulle
    surfPetite = pi * Mousse[indPetite].rayon**2
    surfGrosse = pi * Mousse[indGrosse].rayon**2
    surfGrosseApresCollision = surfPetite + surfGrosse
    rayonGrosseApresCollision = sqrt(surfGrosseApresCollision/pi)

    #réduction de 50% de la vitesse de la grosse bulle
    Mousse[indGrosse].dirx = 0.5 * Mousse[indGrosse].dirx
    Mousse[indGrosse].diry = 0.5 * Mousse [indGrosse].diry

    #suppression de la petite bulle dans Mousse
    Mousse[indPetite] = None

Exercice 10

Exercice 3 (partie A et B) du sujet Métropole J1 2024

Partie A

Correction Q1 
chien40 = Chien(40, 'Duke', 'wheel dog', 10)
Correction Q2 
1
2
def changer_role(self, nouveau_role):
    self.role = nouveau_role
Correction Q3 
chien40.changer_role('leader')

Partie B

Correction Q4 
1
2
3
4
5
6
def retirer_chien(self, numero):
    nouvelle_liste = []
    for chien in self.liste_chiens:
        if chien.id_chien != numero:
            nouvelle_liste.append(chien)
    self.liste_chiens = nouvelle_liste

Exercice 11

Exercice 3 du sujet Amérique du Nord J2 2024

⚠ À la question 9, le code à utiliser est celui ci : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def calculer_solde(self, utilisateur):
    if self.bloc_precedent is None:
        solde = 0
    else:
        solde = ...
        for transaction in self.liste_transactions:
            if ... == utilisateur:
                solde = solde - ...
            elif ...:
                ...
        return solde