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)

Exercice 6

ÉnoncéCorrection

On définit une classe gérant une adresse IPv4.

On rappelle qu’une adresse IPv4 est une adresse de longueur 4 octets, notée en décimale à point, en séparant chacun des octets par un point. On considère un réseau privé avec une plage d’adresses IP de 192.168.0.0 à 192.168.0.255.

On considère que les adresses IP saisies sont valides.

Les adresses IP 192.168.0.0 et 192.168.0.255 sont des adresses réservées.

Le code ci-dessous implémente la classe AdresseIP.

class AdresseIP:
    def __init__(self, adresse):
        self.adresse = ... 

    def liste_octets(self):
        """
        renvoie une liste de nombres entiers,
        la liste des octets de l'adresse IP
        """
        # Note : split découpe la chaine de caractères 
        # en fonction du séparateur
        return [int(i) for i in self.adresse.split(".")]

    def est_reservee(self):
        """
        renvoie True si l'adresse IP est une adresse
        réservée, False sinon
        """
        reservees = [ ... ] 
        return ... 

    def adresse_suivante(self):
        """
        renvoie un objet de AdresseIP avec l'adresse
        IP qui suit l'adresse self si elle existe et None sinon
        """
        octets = ... 
        if ... : 
            return None
        octet_nouveau = ... + ... 
        return ...

Compléter le code ci-dessus et instancier trois objets : adresse1, adresse2, adresse3 avec respectivement les arguments suivants : '192.168.0.1', '192.168.0.2', '192.168.0.0'.

Vérifier que:

>>> adresse1.liste_octets()
[192, 168, 0, 1]
>>> adresse1.est_reservee()
False
>>> adresse3.est_reservee()
True
>>> adresse2.adresse_suivante().adresse # acces valide à adresse
# ici car on sait que l'adresse suivante existe
'192.168.0.3'

Exercices Type BAC

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