Exercices pour débuter☘

Les exercices ci-dessous ont pour but de vous familiariser avec la programmation orientée objet.

Prenez l'habitude de revenir vous entraîner régulièrement avec ces exercices tout au long de l'année. Ils sont généralement accompagnés de pistes et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
Avez-vous testé le programme avec les propositions de tests données dans l'exercice ?
Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?

Rappels

Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
Enregistrez ce fichier dans le dossier [D01-POO] avec le nom donné à l'exercice : ProgD01.51.py, ProgD01.52.py, etc...
Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].

ProgD01.51☘

Programmez et testez la classe Duree étudiée en travaux dirigés.

Solution

class Duree:
    """
    Une classe (structure de données) pour
    représenter un temps en heures-minutes-secondes
    """

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

    def __repr__(self):
        return f"{self.heures} h {self.minutes} min {self.secondes} s"


    def __str__(self):
        """Même affichage que pour la méthode __repr()."""
        return self.__repr__()


    def normaliser(self):
        self.minutes += self.secondes//60
        self.secondes = self.secondes%60
        self.heures += self.minutes//60
        self.minutes = self.minutes%60
        self.heures = self.heures%24


    def __add__(self, tps) :
        """
        self – Duree, celle « à gauche » du +
        tps – Duree, celle « à droite » du +
        Sortie : Duree, au format normalisé
        """
        s = self.secondes + tps.secondes
        m = self.minutes + tps.minutes
        h = self.heures + tps.heures
        resultat = Duree(h, m, s)
        resultat.normaliser()
        return resultat

ProgD01.52☘

Définir une classe Livre en Python dont les attributs sont titre, auteur et prix.
Pour cela :

Écrire sa documentation.
Programmer le constructeur __init__().
Attention, le prix doit être un nombre. Ajouter une assertion pour le vérifier.
Programmer le destructeur __del__().
Programmer la méthode est_titre() qui renvoie True si le titre passé en paramètre est celui du livre, False sinon.
Programmer la méthode est_moins_cher() qui renvoie True si le Livre passé en paramètre est vendu plus cher que celui sur lequel s'applique la méthode, False sinon.

Exemples de tests

>>> d = Livre("a", "b", "tarif")
AssertionError: Le prix tarif doit être de type nombre (float ou int)

>>> d = Livre("a", "b", 12)

>>> d.est_titre("a")
True

>>> d.est_titre("b")
False

>>> e = Livre("b", "c", 14)

>>> d.est_moins_cher(e)
True

>>> e.est_moins_cher(d)
False

Une piste - un code à compléter

class Livre:
    """
    Une classe (structure de données) pour
    représenter un livre
    """

    def __init__(self, titre, auteur, prix) :
        pass

    def __del__(self) :
        pass

    def est_titre(self, chaine):
        pass

    def est_moins_cher(self, autreLivre):
        pass

Une solution

class Livre:
    """
    Une classe (structure de données) pour
    représenter un livre
    """

    def __init__(self, titre, auteur, prix) :
        self.titre = titre
        self.auteur = auteur
        assert isinstance(prix, float) or isinstance(prix, int), f"Le prix {prix} doit être de type nombre (float ou int)"
        self.prix = prix

    def __del__(self) :
        print("Livre détruit.")

    def est_titre(self, chaine):
        return chaine == self.titre

    def est_moins_cher(self, autreLivre):
        return self.prix <= autreLivre.prix

ProgD01.53☘

Définir une classe Angle en Python dont l'unique attribut angle est un entier, sa valeur par défaut étant 0. Cette classe représente un angle mesuré en degrés.

Programmer le constructeur __init__().
Attention, l'angle doit être un entier. Ajouter une assertion pour le vérifier.
Surcharger les méthodes d'affichage __repr__() et __str__(). Les deux méthodes fournissent le même affichage du type "127°".
Programmer une méthode normaliser() qui modifie la valeur de l'angle de sorte que celui-ci soit toujours compris entre 0 et 359. Appeler ensuite cette méthode dans le constructeur pour normaliser l'entier saisit en paramètre lors de l'instanciation d'un nouvel angle.
Exemple de test

Si l'initialisation est :
```
>>> a = Angle(970)
```
alors la valeur d'angle est modifiée automatiquement et l'affichage donnera :
```
>>> a
250°
```
Programmer la méthode get_angle() qui renvoie la valeur de l'attribut angle de l'instance sur laquelle la méthode est appliquée.
Programmer la méthode set_angle() qui modifie par effet de bord la valeur de l'attribut angle sur lequel la méthode est appliquée.
Exemple de test
```
>>> a = Angle(143)

>>> a.set_angle(225)

>>> print(a)
225°
```
Attention
Ne pas oublier de normaliser la valeur de l'angle...
```
>>> a = Angle(143)

>>> a.set_angle(1225)

>>> print(a)
145°
```
Surcharger les opérateurs d'addition et de soustraction.
Attention, la mesure de l'Angle renvoyée soit être comprise entre 0 et 359.
Ajouter un programme de test dans le main.

Une piste - un code à compléter

class Angle:
    """Angles entiers en degrés compris entre 0 et 359"""

    def __init__(self, angle = 0):
        pass

    def normaliser(self):
        pass

    def __repr__(self):
        pass

    def __str__(self):
        pass

    def get_angle(self):
        pass

    def set_angle(self, valeur):
        pass

    def __add__(self, autreAngle):
        pass

    def __sub__(self, autreAngle):
        pass

if __name__ == "__main__":
    # Programme principal à compléter

Une solution

class Angle:
    """Angles entiers en degrés compris entre 0 et 359"""

    def __init__(self, angle = 0):
        assert isinstance(angle, int), "Le paramètre doit être entier."
        self.angle = angle
        self.normaliser()

    def normaliser(self):
        self.angle = self.angle%360

    def __repr__(self):
        return f"{self.angle}°"

    def __str__(self):
        return self.__repr__()

    def get_angle(self):
        return self.angle

    def set_angle(self, valeur):
        assert isinstance(valeur, int), "Le paramètre doit être entier."
        self.angle = valeur
        self.normaliser()

    def __add__(self, autreAngle):
        valeur = self.angle + autreAngle.angle
        return Angle(valeur)

    def __sub__(self, autreAngle):
        valeur = self.angle - autreAngle.angle
        return Angle(valeur)

if __name__ == "__main__":
    a1 = Angle(970)
    a2 = Angle()

    print("Affichages :")
    print("a1 :", a1)
    print("a2 :", a2)

    print("\nget et set :")
    angle = a1.get_angle()
    print("Angle de a1 :", angle)
    print("On modifie la mesure de l'angle a2 :")
    a2.set_angle(1225)
    print("a2 :", a2)

    print("\nAddition et soustraction :")
    a3 = a1+a2
    print("Somme a3 = a1 :", a3)
    a4 = a1-a2
    print("Différence a4 :", a4)