T2.1 POO: Exercices

Exercice 1

ÉnoncéCorrection

1. Compléter la classe Balle avec la méthode avance qui doit actualiser les coordonnées de l'objet en gérant les rebonds sur les bords de la fenêtre.
2. Créer une liste de 100 instances de cette classe et compléter la boucle des événements.
3. Si possible, gérer les collisions...

Exercice 2

ÉnoncéCorrection

1. Écrire une classe Voiture qui contiendra les attributs kilometrage, consommation dont les valeurs seront données comme arguments à l'initialisation et un attribut carburant valant 0 par défaut.
2. Doter la classe d'une méthode affiche qui donne le kilométrage et le carburant disponible.
3. Doter la classe d'une méthode remplir qui prend en argument un entier correspondant au volume de carburant à ajouter au réservoir.
4. Doter la classe d'une méthode avance qui prend en argument un entier correspondant au nombre de kilomètres parcourus et qui actualise les valeurs des attributs kilometrage et carburant.

Exemple d'utilisation de la classe

>>> christine = Voiture(0, 8)
>>> christine.affiche()
La voiture a parcouru 0 kilomètres et il y a 0 litres d'essence dans le réservoir.
>>> christine.remplir(25)
>>> christine.avance(200)
>>> christine.affiche()
La voiture a parcouru 200 kilomètres et il y a 9.0 litres d'essence dans le réservoir.

class Voiture:
    def __init__(self, km, conso):
        self.kilometrage = km
        self.consommation = conso
        self.carburant = 0

    def affiche(self):
        return f'La voiture a parcouru {self.kilometrage} kilomètres et il y a {self.carburant} litres d essence dans le réservoir.')

    def remplir(self, litres):
        self.carburant += litres

    def avance(self, kilometres):
        self.kilometrage += kilometres
        self.carburant -= kilometres/100 * self.consommation

Exercice 3

ÉnoncéCorrection

1. Écrire une classe Chrono qui contiendra les attributs heures, minutes et secondes.
2. Doter la classe d'une méthode affiche() qui 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

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

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

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

    def avance(self, s):
        self.secondes += s
        self.minutes += self.secondes // 60
        self.secondes = self.secondes % 60
        self.heures += self.minutes // 60
        self.minutes = self.minutes % 60

Exercice 4

ÉnoncéCorrection

É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

class Player:
    def __init__(self):
        self.energie = 3
        self.alive = True

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

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

Exercice 5

ÉnoncéCorrection

On souhaite construire une base d'objets servant à créer des jeux utilisant des dés.

• Un dé doit posséder un nombre de faces, ainsi qu'une valeur (la face supérieure du dé une fois qu'on l'a lancé, et la valeur -1 s'il n'a pas encore été lancé). On doit pouvoir lancer le dé, c'est-à-dire lui attribuer une valeur aléatoire entre 1 et son nombre de faces).

• Un jeu de dés possède un nombre de dés ainsi qu'un ensemble de ces dés. On doit pouvoir lancer tous les dés (en une fois), faire la somme des valeurs des dés, et on souhaite afficher la valeur des dés ainsi que leur somme.

Questions:

1. Créer un diagramme de classe pour deux classes représentant ce problème: une classe Jeu et une classe De.
2. Écrire les classes, sachant qu'une instance de classe Jeu doit prendre en arguments le nombre de dés et le nombre de faces de chaque dé (identique pour tous les dés), et qu'une instance de classe De doit prendre en argument son nombre de faces.

Exemples d'utilisation

>>> j = Jeu(3, 6)  #pour créer un jeu de 3 dés à 6 faces
>>> print(j)
Les dés n'ont pas été lancés
>>> j.lancer()
>>> j.somme()
13
>>> print(j)
Les dés valent 2, 5 et 6 et leur somme vaut 13.

import random

class De():
    def __init__(self, n):
        self.nb_faces = n
        self.valeur = -1

    def lancer(self):
        self.valeur = random.randint(1, self.nb_faces)

class Jeu:
    def __init__(self, n, f):
        self.nb_des = n
        self.faces_de = f
        self.des = [De(self.faces_de) for _ in range(self.nb_des)]

    def lancer(self):
        for de in self.des:
            de.lancer()

    def somme(self):
        s = 0
        for de in self.des:
            s += de.valeur
        return s

    # ou return sum([de.valeur for de in self.des])

    def __str__(self):
        if self.somme() < 0:
            return 'Les dés n ont pas été lancés'
        else:
            valeurs = ', '.join([str(self.des[k].valeur) for k in range(self.nb_des-1)])
            return f'Les dés valent {valeurs} et {self.des[-1].valeur} et leur somme vaut {self.somme()}.'



j = Jeu(3, 6)

Exercices Type BAC

Énoncé 1 Énoncé 2 Énoncé 3 (EP)

Correction EP

Exercice 1

def min_et_max(tab:list) -> dict:
    '''
    Renvoie la plus petite et la plus grande valeur du tableau sous la forme d’un
    dictionnaire à deux clés 'min' et 'max'.
    Précondition: tab est non vide.

    >>> min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1])
    {'min': -2, 'max': 9}
    >>> min_et_max([0, 1, 2, 3])
    {'min': 0, 'max': 3}
    >>> min_et_max([3])
    {'min': 3, 'max': 3}
    >>> min_et_max([1, 3, 2, 1, 3])
    {'min': 1, 'max': 3}
    >>> min_et_max([-1, -1, -1, -1, -1])
    {'min': -1, 'max': -1}
    '''
    assert tab != [], "tableau vide"

    extremes = {'min': tab[0], 'max': tab[0]}
    for nombre in tab:
        if nombre < extremes['min']:
            extremes['min'] = nombre
        elif nombre > extremes['max']:
            extremes['max'] = nombre
    return extremes

Exercice 2:

class Carte:
    def __init__(self, c, v):
        """ Initialise les attributs couleur (entre 1 et 4), et valeur (entre 1 et 13). """
        self.couleur = c
        self.valeur = v

    def get_valeur(self):
        """ Renvoie la valeur de la carte : As, 2, ..., 10, Valet, Dame, Roi """
        valeurs = ['As','2', '3', '4', '5', '6', '7', '8', '9', '10', 'Valet', 'Dame', 'Roi']
        return valeurs[self.valeur - 1]

    def get_couleur(self):
        """ Renvoie la couleur de la carte (parmi pique, coeur, carreau, trèfle). """
        couleurs = ['pique', 'coeur', 'carreau', 'trèfle']
        return couleurs[self.couleur - 1]

class Paquet_de_cartes:
    def __init__(self):
        """ Initialise l'attribut contenu avec une liste des 52 objets Carte possibles
            rangés par valeurs croissantes en commençant par pique, puis coeur,
            carreau et tréfle. """
        self.contenu = [Carte(c, v) for c in range(1, 5) for v in range(1, 14)]

    def get_carte(self, pos):
        """ Renvoie la carte qui se trouve à la position pos (entier compris entre 0 et 51). """
        assert pos >= 0 and pos < 52, "paramètre pos invalide"
        return self.contenu[pos]

jeu = Paquet_de_cartes()
carte1 = jeu.get_carte(20)
carte2 = jeu.get_carte(0)
print(carte1.get_valeur() + " de " + carte1.get_couleur())
print(carte2.get_valeur() + " de " + carte2.get_couleur())
carte3 = jeu.get_carte(52)

"