Exercice Corrigé: Les classes POO Python – Partie 6

# Définir la classe Produit
class Produit:
    # Constructeur pour initialiser le nom et la quantité du produit
    def __init__(self, nom, quantite):
        # Affecter le paramètre nom au champ nom
        self.nom = nom
        # Affecter le paramètre quantite au champ quantite
        self.quantite = quantite

    # Méthode pour obtenir le nom du produit
    def get_nom(self):
        # Retourner la valeur du champ nom
        return self.nom

    # Méthode pour définir le champ nom
    def set_nom(self, nom):
        # Affecter le paramètre nom au champ nom
        self.nom = nom

    # Méthode pour obtenir la quantité du produit
    def get_quantite(self):
        # Retourner la valeur du champ quantite
        return self.quantite

    # Méthode pour définir le champ quantite
    def set_quantite(self, quantite):
        # Affecter le paramètre quantite au champ quantite
        self.quantite = quantite


# Définir la classe Stock
class Stock:
    # Constructeur pour initialiser la liste des produits
    def __init__(self):
        # Créer une liste vide pour stocker les objets Produit
        self.produits = []

    # Méthode pour ajouter un produit à la liste des produits
    def add_produit(self, produit):
        # Ajouter le produit spécifié à la liste des produits
        self.produits.append(produit)

    # Méthode pour supprimer un produit de la liste des produits
    def remove_produit(self, produit):
        # Supprimer le produit spécifié de la liste des produits
        self.produits.remove(produit)

    # Méthode pour vérifier si les produits en stock sont 
    # insuffisants
    def check_stock(self):
        # Itérer dans la liste des produits
        for p in self.produits:
            # Vérifier si la quantité du produit est inférieure ou 
            # égale à 100
            if p.get_quantite() <= 100:
                # Afficher un message indiquant que le produit est en 
                # rupture de stock
                print(f"{p.get_nom()} est en rupture de stock. La quantité actuelle: {p.get_quantite()}")


# Définir la fonction principale
def main():
    # Créer une nouvelle instance de la classe Stock
    stock = Stock()

    # Créer de nouveaux objets Produit avec nom et quantité
    p1 = Produit("Souris", 300)
    p2 = Produit("Clavier", 70)
    p3 = Produit("Tablette", 40)

    print("Ajouter trois produits en stock:")
    stock.add_produit(p1)
    stock.add_produit(p2)
    stock.add_produit(p3)

    print("\nVérifier la disponibilité des stocks:")
    # Vérifier et afficher les produits dont le stock est insuffisant
    stock.check_stock()

    print("\nSupprimer la tablette du stock!")
    # Supprimer le produit Tablette du stock
    stock.remove_produit(p3)

    print("\nVérifier à nouveau la disponibilité des stocks:")
    # Vérifier et afficher les produits dont le stock est insuffisant
    stock.check_stock()


# Point d'entrée du programme
if __name__ == "__main__":
    main()

Sortie:

Ajouter trois produits en stock:

Vérifier la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70
Tablette est en rupture de stock. La quantité actuelle: 40

Supprimer la tablette du stock!

Vérifier à nouveau la disponibilité des stocks:
Clavier est en rupture de stock. La quantité actuelle: 70

# Importer les types nécessaires
from typing import List

# Définir la classe Etudiant
class Etudiant:
    # Constructeur pour initialiser le nom et l'âge de l'étudiant
    def __init__(self, nom: str, age: int):
        self.nom = nom  # Champ pour stocker le nom
        self.age = age  # Champ pour stocker l'âge

    # Méthode Getter pour le champ nom
    def get_nom(self) -> str:
        return self.nom

    # Méthode Setter pour le champ nom
    def set_nom(self, nom: str):
        self.nom = nom

    # Méthode Getter pour le champ age
    def get_age(self) -> int:
        return self.age

    # Méthode Setter pour le champ age
    def set_age(self, age: int):
        self.age = age


# Définir la classe Enseignant
class Enseignant:
    # Constructeur pour initialiser le nom et la matière
    def __init__(self, nom: str, matiere: str):
        self.nom = nom  # Champ pour stocker le nom
        self.matiere = matiere  # Champ pour stocker la matière

    # Méthode Getter pour le champ nom
    def get_nom(self) -> str:
        return self.nom

    # Méthode Setter pour le champ nom
    def set_nom(self, nom: str):
        self.nom = nom

    # Méthode Getter pour le champ matiere
    def get_matiere(self) -> str:
        return self.matiere

    # Méthode Setter pour le champ matiere
    def set_matiere(self, matiere: str):
        self.matiere = matiere


# Définir la classe Classe
class Classe:
    # Constructeur pour initialiser les champs nomClasse, enseignant 
    # et etudiants
    def __init__(self, nom_classe: str, enseignant: Enseignant):
        # Champ pour stocker le nom de la classe
        self.nom_classe = nom_classe  
        # Champ pour stocker l'enseignant
        self.enseignant = enseignant  
        # Liste d'étudiants
        self.etudiants: List[Etudiant] = []  

    # Méthode Getter pour le champ nomClasse
    def get_nom_classe(self) -> str:
        return self.nom_classe

    # Méthode Setter pour le champ nomClasse
    def set_nom_classe(self, nom_classe: str):
        self.nom_classe = nom_classe

    # Méthode Getter pour le champ enseignant
    def get_enseignant(self) -> Enseignant:
        return self.enseignant

    # Méthode Setter pour le champ enseignant
    def set_enseignant(self, enseignant: Enseignant):
        self.enseignant = enseignant

    # Méthode pour récupérer la liste des étudiants
    def get_etudiants(self) -> List[Etudiant]:
        return self.etudiants

    # Méthode pour ajouter un étudiant à la liste
    def add_etudiant(self, e: Etudiant):
        self.etudiants.append(e)

    # Méthode pour supprimer un étudiant de la liste
    def remove_etudiant(self, e: Etudiant):
        self.etudiants.remove(e)


# Définir la classe Ecole
class Ecole:
    # Constructeur pour initialiser les champs élèves, enseignants et 
    # classes
    def __init__(self):
        # Liste d'étudiants
        self.etudiants: List[Etudiant] = []  
        # Liste d'enseignants
        self.enseignants: List[Enseignant] = []  
        # Liste de classes
        self.classes: List[Classe] = []  

    # Méthode pour ajouter un étudiant
    def add_etudiant(self, student: Etudiant):
        self.etudiants.append(student)

    # Méthode pour supprimer un étudiant
    def remove_etudiant(self, student: Etudiant):
        self.etudiants.remove(student)

    # Méthode pour ajouter un enseignant
    def add_enseignant(self, teacher: Enseignant):
        self.enseignants.append(teacher)

    # Méthode pour supprimer un enseignant
    def remove_enseignant(self, teacher: Enseignant):
        self.enseignants.remove(teacher)

    # Méthode pour ajouter une classe
    def add_classe(self, school_class: Classe):
        self.classes.append(school_class)

    # Méthode pour supprimer une classe
    def remove_classe(self, school_class: Classe):
        self.classes.remove(school_class)

    # Méthode pour récupérer la liste des étudiants
    def get_etudiants(self) -> List[Etudiant]:
        return self.etudiants

    # Méthode pour récupérer la liste des enseignants
    def get_enseignants(self) -> List[Enseignant]:
        return self.enseignants

    # Méthode pour récupérer la liste des classes
    def get_classes(self) -> List[Classe]:
        return self.classes


# Classe principale pour exécuter le programme
if __name__ == "__main__":
    # Créer une nouvelle instance de la classe Ecole
    ecole = Ecole()

    # Créer des objets Etudiant avec nom et âge
    et1 = Etudiant("Alex Babtise", 20)
    et2 = Etudiant("Bob Firok", 25)
    et3 = Etudiant("Emily Taylor", 22)
    et4 = Etudiant("Ali Binani", 23)

    # Ajouter les étudiants à l'école
    ecole.add_etudiant(et1)
    ecole.add_etudiant(et2)
    ecole.add_etudiant(et3)
    ecole.add_etudiant(et4)

    # Créer de nouveaux objets Enseignant avec nom et matière
    es1 = Enseignant("Yohan Sinor", "Math")
    es2 = Enseignant("Thomas Fiza", "Anglais")
    es3 = Enseignant("Olivier Bibo", "Science")

    # Ajouter les enseignants à l'école
    ecole.add_enseignant(es1)
    ecole.add_enseignant(es2)
    ecole.add_enseignant(es3)

    # Créer de nouveaux objets Classe
    class_math = Classe("Mathematics", es1)
    class_math.add_etudiant(et1)
    class_math.add_etudiant(et2)
    class_math.add_etudiant(et3)
    class_math.add_etudiant(et4)

    class_anglais = Classe("Anglais", es2)
    class_anglais.add_etudiant(et1)
    class_anglais.add_etudiant(et2)
    class_anglais.add_etudiant(et3)

    class_science = Classe("Science", es3)
    class_science.add_etudiant(et1)
    class_science.add_etudiant(et2)
    class_science.add_etudiant(et3)
    class_science.add_etudiant(et4)

    # Ajouter les classes à l'école
    ecole.add_classe(class_math)
    ecole.add_classe(class_anglais)
    ecole.add_classe(class_science)

    # Afficher des informations générales sur l'école
    print("Informations sur l'école:")
    print("Nombre d'étudiants:", len(ecole.get_etudiants()))
    print("Nombre d'enseignants:", len(ecole.get_enseignants()))
    print("Nombre de classes:", len(ecole.get_classes()))
    print()

    # Afficher les informations sur les cours
    for school_class in ecole.get_classes():
        print(f"Informations sur les cours de {school_class.get_nom_classe()}:")
        print("Nom de la classe:", school_class.get_nom_classe())
        print("Enseignant:", school_class.get_enseignant().get_nom())
        print("Nombre d'étudiants:", len(school_class.get_etudiants()))
        print()

    # Supprimer un élève, un enseignant et une classe de l'école
    ecole.remove_etudiant(et1)
    ecole.remove_enseignant(es2)
    ecole.remove_classe(class_math)

    # Afficher les informations mises à jour sur l'école
    print("Informations sur l'école après suppression d'un élève, d'un enseignant et d'une classe:")
    print("Nombre d'étudiants:", len(ecole.get_etudiants()))
    print("Nombre d'enseignants:", len(ecole.get_enseignants()))
    print("Nombre de classes:", len(ecole.get_classes()))

Sortie:

Informations sur l'école:
Nombre d'étudiants: 4
Nombre d'enseignants: 3
Nombre de classes: 3

Informations sur les cours de mathématiques:
Nom de Class: Mathematics
Enseignant: Yohan Sinor
Nombre d'étudiants: 4

Informations sur les cours d'anglais:
Nom de Class: Anglais
Enseignant: Thomas Fiza
Nombre d'étudiants: 3

Informations sur les cours de sciences:
Nom de Class: Science
Enseignant: Olivier Bibo
Nombre d'étudiants: 4

Informations sur l'école après suppression d'un élève, d'un enseignant et d'une classe:
Nombre d'étudiants: 3
Nombre d'enseignants: 2
Nombre de classes: 2

import random  # Importer le module random

# Définir la classe Chanson
class Chanson:
    # Constructeur pour la classe Chanson
    def __init__(self, title, artist):
        # Initialiser le champ titre et artiste
        self.title = title
        self.artist = artist

    # Méthode Getter pour récupérer le titre de la chanson
    def get_titre(self):
        return self.title

    # Méthode pour modifier le titre de la chanson
    def set_titre(self, title):
        self.title = title

    # Méthode Getter pour récupérer l'artiste de la chanson
    def get_artist(self):
        return self.artist

    # Méthode pour modifier le nom de l'artiste de la chanson
    def set_artist(self, artist):
        self.artist = artist

# Définir la classe BiblioMusicale
class BiblioMusicale:
    # Constructeur pour la classe BiblioMusicale
    def __init__(self):
        # Créer une nouvelle liste pour stocker les objets Chanson
        self.chansons = []

    # Méthode pour ajouter une chanson à la bibliothèque
    def add_chanson(self, song):
        # Ajouter la chanson fournie à la liste des chansons
        self.chansons.append(song)

    # Méthode pour supprimer une chanson de la bibliothèque
    def remove_chanson(self, song):
        # Supprimer la chanson fournie de la liste des chansons
        self.chansons.remove(song)

    # Méthode pour obtenir la liste de toutes les chansons
    def get_chanson(self):
        return self.chansons

    # Méthode pour lire une chanson aléatoire de la bibliothèque
    def lire_chanson_aleatoire(self):
        # Vérifier si la bibliothèque est vide
        if not self.chansons:
            print("Il n'y a pas de chansons à lire.")
            return  # Quitter la méthode
        
        # Générer un index aléatoire dans l'intervalle de la liste 
        # des chansons
        index = random.randint(0, len(self.chansons) - 1)
        # Afficher le titre et l'artiste de la chanson sélectionnée
        print(f"Lire: {self.chansons[index].get_titre()} par {self.chansons[index].get_artist()}")

# Définir la classe Main
if __name__ == "__main__":
    # Créer une nouvelle instance de la classe BiblioMusicale
    biblio = BiblioMusicale()

    # Ajouter des chansons à la bibliothèque musicale
    biblio.add_chanson(Chanson("Un clair de lune", "Jean Chérasse"))
    biblio.add_chanson(Chanson("Cadet Rousselle", "André Hunebelle"))
    biblio.add_chanson(Chanson("Help!", "Richard Lester"))
    biblio.add_chanson(Chanson("Baisers volés", "François Truffaut"))
    biblio.add_chanson(Chanson("Je t'aime", "Serge Gainsbourg"))
    biblio.add_chanson(Chanson("Staying Alive", "Michel Blanc"))

    # Afficher toutes les chansons de la bibliothèque musicale
    print("Toutes les chansons:")
    for chanson in biblio.get_chanson():
        print(f"{chanson.get_titre()} par {chanson.get_artist()}")

    print("\nLecture d'une chanson aléatoire:")
    # Lire et afficher trois fois une chanson choisie au hasard dans 
    # la bibliothèque
    biblio.lire_chanson_aleatoire()
    print()
    biblio.lire_chanson_aleatoire()
    print()
    biblio.lire_chanson_aleatoire()

Sortie:

Toutes les chansons:
Un clair de lune par Jean Chérasse
Cadet Rousselle par André Hunebelle
Help! par Richard Lester
Baisers volés par François Truffaut
Je t'aime par Serge Gainsbourg
Staying Alive par Michel Blanc

Lecture d'une chanson aléatoire:
Lire: Help! par Richard Lester

Lire: Baisers volés par François Truffaut

Lire: Help! par Richard Lester

from abc import ABC, abstractmethod
import math

# Définir la classe Forme comme une classe abstraite
class Forme(ABC):
    # Méthode abstraite pour récupérer la surface de la forme
    @abstractmethod
    def get_surface(self):
        pass

    # Méthode abstraite pour récupérer le périmètre de la forme
    @abstractmethod
    def get_perimeter(self):
        pass

# Définir la classe Rectangle, qui hérite de la classe Forme
class Rectangle(Forme):
    # Constructeur pour initialiser la longueur et la largeur du 
    # rectangle
    def __init__(self, longueur, largeur):
        self.longueur = longueur  # Attribuer la longueur
        self.largeur = largeur    # Attribuer la largeur

    # Méthode pour calculer et renvoyer la surface du rectangle
    def get_surface(self):
        # Surface = longueur * largeur
        return self.longueur * self.largeur  

    # Méthode pour calculer et renvoyer le périmètre du rectangle
    def get_perimeter(self):
        # Périmètre = 2 * (longueur + largeur)
        return 2 * (self.longueur + self.largeur)  

# Définir la classe Cercle, qui hérite de la classe Forme
class Cercle(Forme):
    # Constructeur pour initialiser le rayon du cercle
    def __init__(self, rayon):
        self.rayon = rayon  # Attribuer le rayon

    # Méthode pour calculer et renvoyer la surface du cercle
    def get_surface(self):
        return math.pi * self.rayon ** 2  # Surface = π * rayon^2

    # Méthode pour calculer et renvoyer le périmètre du cercle
    def get_perimeter(self):
        return 2 * math.pi * self.rayon  # Périmètre = 2 * π * rayon

# Définir la classe Triangle, qui hérite de la classe Forme
class Triangle(Forme):
    # Constructeur pour initialiser les côtés du triangle
    def __init__(self, c1, c2, c3):
        self.c1 = c1
        self.c2 = c2
        self.c3 = c3

    # Méthode pour calculer et renvoyer la surface du triangle
    def get_surface(self):
        # Calculer le semi-périmètre
        s = (self.c1 + self.c2 + self.c3) / 2  
        # Formule de Heron
        return math.sqrt(s * (s - self.c1) * (s - self.c2) * (s - self.c3))  

    # Méthode pour calculer et renvoyer le périmètre du triangle
    def get_perimeter(self):
        # Périmètre = somme des côtés
        return self.c1 + self.c2 + self.c3  

# Définir la classe Main
if __name__ == "__main__":
    # Créer un rectangle de longueur 15 et de largeur 20
    rectangle = Rectangle(15, 20)

    # Créer un cercle de rayon 5
    circle = Cercle(5)

    # Créer un triangle dont les côtés sont 5, 7 et 9
    triangle = Triangle(5, 7, 9)

    print("\nSurface et périmètre de différentes formes:")

    # Afficher les détails et calculs du rectangle
    print("\nRectangle:")
    print("Surface:", rectangle.get_surface())
    print("Périmètre:", rectangle.get_perimeter())

    # Afficher les détails et calculs du cercle
    print("\nCercle:")
    print("Surface:", circle.get_surface())
    print("Périmètre:", circle.get_perimeter())

    # Afficher les détails et calculs du triangle
    print("\nTriangle:")
    print("Surface:", triangle.get_surface())
    print("Périmètre:", triangle.get_perimeter())

Sortie:

Surface et périmètre de différentes formes:

Rectangle:
Surface: 300.0
Périmètre: 70.0

Cercle:
Surface: 78.53981633974483
Périmètre: 31.41592653589793

Triangle:
Surface: 17.41228014936585
Périmètre: 21.0

from typing import List

# Définir la classe Avis
class Avis:
    # Constructeur pour initialiser le texte de l'avis, le nom de 
    # l'avis et la note
    def __init__(self, text_avis: str, nom_avis: str, note: float):
        self.text_avis = text_avis # Initialiser le texte de l'avis
        self.nom_avis = nom_avis   # Initialiser le nom de l'avis
        self.note = note           # Initialiser la note

    # Méthode pour récupérer le texte de l'avis
    def get_text_avis(self) -> str:
        return self.text_avis  # Retourner le texte de l'avis

    # Méthode pour récupérer le nom de l'avis
    def get_nom_avis(self) -> str:
        return self.nom_avis  # Retourner le nom de l'avis

    # Méthode pour récupérer la note
    def get_note(self) -> float:
        return self.note  # Retourner la note


# Définir la classe Film
class Film:
    # Constructeur pour initialiser le titre, le directeur et les 
    # acteurs du film
    def __init__(self, titre: str, directeur: str, acteurs: List[str]):
        self.titre = titre         # Initialiser le titre
        self.directeur = directeur # Initialiser le directeur
        self.acteurs = acteurs     # Initialiser la liste des acteurs
        self.avis = []             # Initialiser la liste des avis

    # Méthode pour ajouter un avis sur le film
    def add_avis(self, a: Avis):
        self.avis.append(a)  # Ajouter l'avis à la liste

    # Méthode pour récupérer la liste de toutes les avis du film
    def get_avis(self) -> List[Avis]:
        return self.avis  # Retourner la liste des avis

    # Méthode pour récupérer le titre du film
    def get_titre(self) -> str:
        return self.titre  # Retourner le titre

    # Méthode pour récupérer le directeur du film
    def get_directeur(self) -> str:
        return self.directeur  # Retourner le directeur

    # Méthode pour récupérer la liste des acteurs d'un film
    def get_acteurs(self) -> List[str]:
        return self.acteurs  # Retourner la liste des acteurs


# Définir la classe Main
if __name__ == "__main__":
    # Créer un objet film
    f1 = Film("La Roue", "Jean Servais", ["Pierre Pelletier", "Pierre Mondy"])

    # Créer des objets d'avis
    avis1 = Avis("Excellent film!", "Alex Babtise", 5.0)
    avis2 = Avis("Fortement recommandé!", "Jean Zino", 4.5)
    avis3 = Avis("Un film magnifique", "Bob Polib", 4.0)

    # Ajouter des avis sur f1
    f1.add_avis(avis1)
    f1.add_avis(avis2)
    f1.add_avis(avis3)

    # Afficher tous les avis sur 'La Roue'
    print(f"\nAvis pour '{f1.get_titre()}':")
    for a in f1.get_avis():
        print(f"{a.get_text_avis()} par {a.get_nom_avis()} - {a.get_note()}")

Sortie:

Avis pour 'La Roue':
Excellent film! par Alex Babtise - 5.0
Fortement recommandé! par Jean Zino - 4.5
Un film magnifique par Bob Polib - 4.0