Exercice Corrigé: Les classes POO Python – Partie 7

import random

# Définir la classe Voyage
class Voyage:
    # Constructeur pour initialiser les listes de vols et d'hôtels
    def __init__(self):
        # Initialiser la liste des vols
        self.vols = []
        # Initialiser la liste des hôtels
        self.hotels = []

    # Méthode pour rechercher des vols
    def rechercher_vols(self, orig, dest, date, nbr_voyageur):
        # Afficher les détails de la recherche de vols
        print(f"Recherche de vols de {orig} à {dest} le {date} pour {nbr_voyageur} voyageurs.")

    # Méthode pour rechercher des hôtels
    def rechercher_hotels(self, lieu, date_arriv, date_depart, nbr_pers):
        # Afficher les détails de la recherche d'hôtels
        print(f"Recherche d'hôtels dans {lieu} de {date_arriv} à {date_depart} pour {nbr_pers} personnes.")

    # Méthode pour réserver un vol
    def reserver_vol(self, num_vol, nom_passager, orig, dest, date, nbr_voyageur, prix):
        # Créer un objet vol avec les détails fournis
        vol = Vol(num_vol, nom_passager, orig, dest, date, nbr_voyageur, prix)
        # Générer un numéro de confirmation
        num_conf = self.generate_confirmation_number()
        # Définir le numéro de confirmation du vol
        vol.set_num_conf(num_conf)
        # Ajouter le vol à la liste des vols
        self.vols.append(vol)
        # Afficher le numéro de confirmation du vol réservé
        print(f"Vol réservé ! Numéro de confirmation: {num_conf}")

    # Méthode pour réserver un hôtel
    def reserver_hotel(self, hotel_id, nom_personne, lieu, date_arriv, date_depart, nbr_personne, prix):
        # Créer un objet hôtel avec les détails fournis
        hotel = Hotel(hotel_id, nom_personne, lieu, date_arriv, date_depart, nbr_personne, prix)
        # Générer un numéro de confirmation
        num_conf = self.generate_confirmation_number()
        # Définir le numéro de confirmation de l'hôtel
        hotel.set_num_conf(num_conf)
        # Ajouter l'hôtel à la liste des hôtels
        self.hotels.append(hotel)
        # Afficher le numéro de confirmation de l'hôtel réservé
        print(f"Hôtel réservé ! Numéro de confirmation: {num_conf}")

    # Méthode pour annuler une réservation
    def annuler_reservation(self, num_conf):
        # Parcourir la liste des vols pour trouver la réservation
        for vol in self.vols:
            # Si le numéro de confirmation correspond, supprimer la 
            # réservation de vol
            if vol.get_num_conf() == num_conf:
                self.vols.remove(vol)
                # Afficher le message d'annulation du vol
                print(f"Annulation de la réservation de vol avec le numéro de confirmation {num_conf}")
                return

        # Parcourir la liste des hôtels pour trouver la réservation
        for hotel in self.hotels:
            # Si le numéro de confirmation correspond, supprimer la 
            # réservation d'hôtel
            if hotel.get_num_conf() == num_conf:
                self.hotels.remove(hotel)
                # Afficher le message d'annulation d'hôtel
                print(f"Annulation de la réservation d'hôtel avec le numéro de confirmation {num_conf}")
                return

        # Afficher un message si aucune réservation n'a été trouvée 
        # avec le numéro de confirmation fourni
        print(f"Aucune réservation n'a été trouvée avec le numéro de confirmation {num_conf}.")

    # Méthode pour générer un numéro de confirmation aléatoire à 6 
    # chiffres
    def generate_confirmation_number(self):
        # Générer et renvoyer un nombre aléatoire à 6 chiffres
        return random.randint(100000, 999999)

    # Méthode pour récupérer la liste des vols
    def get_vols(self):
        # Retourner la liste des vols
        return self.vols

    # Méthode pour récupérer la liste des hôtels
    def get_hotels(self):
        # Retourner la liste des hôtels
        return self.hotels


# Définir la classe Vol
class Vol:
    # Constructeur pour initialiser l'objet Vol avec les détails 
    # fournis
    def __init__(self, num_vol, nom_passager, origin, destination, date, nbr_passagers, prix):
        # Initialiser les attributs
        self.num_vol = num_vol
        self.nom_passager = nom_passager
        self.origin = origin
        self.destination = destination
        self.date = date
        self.nbr_passagers = nbr_passagers
        self.prix = prix
        self.num_conf = None

    # Méthode pour récupérer le numéro de vol
    def get_num_vol(self):
        return self.num_vol

    # Méthode pour récupérer le nom du passager
    def get_nom_passager(self):
        return self.nom_passager

    # Méthode pour récupérer l'origine du vol
    def get_origin(self):
        return self.origin

    # Méthode pour récupérer la destination du vol
    def get_destination(self):
        return self.destination

    # Méthode pour récupérer la date du vol
    def get_date(self):
        return self.date

    # Méthode pour récupérer le nombre de passagers
    def get_nbr_passagers(self):
        return self.nbr_passagers

    # Méthode pour récupérer le prix du vol
    def get_prix(self):
        return self.prix

    # Méthode pour récupérer le numéro de confirmation
    def get_num_conf(self):
        return self.num_conf

    # Méthode pour définir le numéro de confirmation
    def set_num_conf(self, num_conf):
        self.num_conf = num_conf


# Définir la classe Hotel
class Hotel:
    # Constructeur pour initialiser l'objet Hôtel avec les détails 
    # fournis
    def __init__(self, hotel_id, nom_personne, lieu, date_arriv, date_depart, nbr_personne, prix):
        # Initialiser les attributs
        self.hotel_id = hotel_id
        self.nom_personne = nom_personne
        self.lieu = lieu
        self.date_arriv = date_arriv
        self.date_depart = date_depart
        self.nbr_personne = nbr_personne
        self.prix = prix
        self.num_conf = None

    # Méthode pour récupérer l'identifiant de l'hôtel
    def get_hotel_id(self):
        return self.hotel_id

    # Méthode pour récupérer le nom de l'invité
    def get_nom_personne(self):
        return self.nom_personne

    # Méthode pour récupérer la localisation de l'hôtel
    def get_lieu(self):
        return self.lieu

    # Méthode pour récupérer la date d'enregistrement
    def get_date_arriv(self):
        return self.date_arriv

    # Méthode pour récupérer la date de sortie
    def get_date_depart(self):
        return self.date_depart

    # Méthode pour récupérer le prix du séjour
    def get_prix(self):
        return self.prix

    # Méthode pour récupérer le nombre d'invités
    def get_nbr_personne(self):
        return self.nbr_personne

    # Méthode pour récupérer le numéro de confirmation
    def get_num_conf(self):
        return self.num_conf

    # Méthode pour définir le numéro de confirmation
    def set_num_conf(self, num_conf):
        self.num_conf = num_conf


# Classe principale pour exécuter le programme
if __name__ == "__main__":
    # Créer un nouvel objet Voyage
    app = Voyage()
    # Recherche de vols de Paris à Casablanca le 2024-02-01 pour 1 
    # passager
    app.rechercher_vols("Paris", "Casablanca", "2024-02-01", 1)
    # Recherche des hôtels à Casablanca du 2024-09-01 au 2024-10-05 
    # pour 2 personnes
    app.rechercher_hotels("Casablanca", "2024-09-01", "2024-10-05", 2)
    # Réservez un vol avec le numéro de vol 96342588 pour Alex 
    # Babtise
    app.reserver_vol(96342588, "Alex Babtise", "Paris", "Casablanca", "2024-08-01", 1, 600.00)
    # Réservez un vol avec le numéro de vol 10843563 pour Emily Lyona
    app.reserver_vol(10843563, "Emily Lyona", "Paris", "Casablanca", "2024-08-01", 1, 755.00)
    # Réservez un hôtel avec ID 98765432 pour Martin Nadine
    app.reserver_hotel(98765432, "Martin Nadine", "Casablanca", "2024-09-01", "2024-09-05", 1, 150.00)
    # Annuler la réservation avec le numéro de confirmation 90945840
    app.annuler_reservation(90945840)

Sortie:

Recherche de vols de Paris à Casablanca le 2024-02-01 pour 1 voyageurs.
Recherche d'hôtels dans Casablanca de 2024-09-01 à 2024-10-05 pour 2 personnes.
Vol réservé ! Numéro de confirmation: 100881
Vol réservé ! Numéro de confirmation: 455285
Hôtel réservé ! Numéro de confirmation: 799037
Aucune réservation n'a été trouvée avec le numéro de confirmation 90945840.

# Importer les bibliothèques nécessaires
from typing import List

# Définir la classe Restaurant
class Restaurant:
    # Déclarer des listes pour stocker les plats du menu, les prix, 
    # les notes et le nombre de plats
    def __init__(self):
        # Initialiser la liste des plats
        self.menu = []
        # Initialiser la liste des prix
        self.prix = []
        # Initialiser la liste des notes
        self.notes = []
        # Initialiser la liste du nombre de plats
        self.nbr_de_plats = []

    # Méthode pour ajouter un plat au menu
    def add_plat(self, elem: str, prix_p: float):
        # Ajouter le plat au menu
        self.menu.append(elem)
        # Ajouter le prix à la liste des prix
        self.prix.append(prix_p)
        # Initialiser la note du plat à 0
        self.notes.append(0)
        # Initialiser le compteur du plat à 0
        self.nbr_de_plats.append(0)

    # Méthode pour supprimer un plat du menu
    def remove_plat(self, plat: str):
        # Obtenir l'index du plat dans la liste menu
        if plat in self.menu:
            index = self.menu.index(plat)
            # Supprimer le plat du menu
            del self.menu[index]
            # Retirer le prix correspondant de la liste des prix
            del self.prix[index]
            # Retirer la note correspondante de la liste des notes
            del self.notes[index]
            # Supprimer le nombre de plats correspondant de la liste 
            # nbr_de_plats
            del self.nbr_de_plats[index]

    # Méthode pour ajouter une note à un plat
    def add_note(self, plat: str, note: int):
        # Obtenir l'index du plat dans le menu
        if plat in self.menu:
            index = self.menu.index(plat)
            # Obtenir la note actuelle du plat
            note_act = self.notes[index]
            # Obtenir le nombre actuel du plat
            totale_plats = self.nbr_de_plats[index]
            # Mettre à jour la note du plat
            self.notes[index] = note_act + note
            # Mettre à jour le nombre de plats
            self.nbr_de_plats[index] = totale_plats + 1

    # Méthode pour obtenir la note moyenne d'un plat
    def get_moyenne_note(self, plat: str) -> float:
        # Obtenir l'index du plat dans le menu
        if plat in self.menu:
            index = self.menu.index(plat)
            # Obtenir la note totale du plat
            totale_note = self.notes[index]
            # Obtenir le nombre actuel du plat
            totale_plats = self.nbr_de_plats[index]
            # Calculer et renvoyer la note moyenne du plat
            return totale_note / totale_plats if totale_plats > 0 else 0.0
        else:
            # Retourne 0.0 si le plat n'existe pas dans le menu
            return 0.0

    # Méthode pour afficher le menu
    def afficher_menu(self):
        # Parcourir la liste de menus
        for i in range(len(self.menu)):
            # Afficher le plat et son prix
            print(f"{self.menu[i]}: €{self.prix[i]:.2f}")

    # Méthode de calcul de la note moyenne de tous les plats
    def calculer_note_moyenne(self) -> float:
        # Initialiser la note totale à 0
        note_totale = 0
        # Initialiser le nombre de notes à 0
        nbr_note = 0
        # Parcourir la liste de notes
        for i in range(len(self.notes)):
            # Ajouter la note à note_totale
            note_totale += self.notes[i]
            # Incrémenter nbr_note
            nbr_note += self.nbr_de_plats[i]
        # Calculer et renvoyer la note moyenne
        return note_totale / nbr_note if nbr_note > 0 else 0.0

# Définir la classe principale
if __name__ == "__main__":
    # Créer un nouvel objet Restaurant
    restaurant = Restaurant()
    # Ajouter au menu un plat Bœuf à la ficelle au prix de 15€
    restaurant.add_plat("Bœuf à la ficelle", 15.00)
    # Ajouter au menu un plat de pizzas au prix de 8,99€
    restaurant.add_plat("Pizza", 8.99)
    # Ajouter un plat de salade au prix de 5€ au menu
    restaurant.add_plat("Salade", 5.00)

    print("Menu: Plats et prix")
    # Afficher les plats du menu et leur prix
    restaurant.afficher_menu()

    # Ajouter des notes pour les plats
    restaurant.add_note("Bœuf à la ficelle", 4)
    restaurant.add_note("Bœuf à la ficelle", 5)
    restaurant.add_note("Pizza", 3)
    restaurant.add_note("Pizza", 4)
    restaurant.add_note("Salade", 2)

    # Obtenir et afficher la note moyenne pour le plat Pizza
    note_moyenne = restaurant.get_moyenne_note("Pizza")
    print(f"Note moyenne pour Pizza: {note_moyenne:.2f}")

    # Obtenir et afficher la note moyenne pour le plat Salade
    note_moyenne = restaurant.get_moyenne_note("Salade")
    print(f"Note moyenne pour Salade: {note_moyenne:.2f}")

    # Afficher la note moyenne totale pour tous les plats
    print(f"Note moyenne: {restaurant.calculer_note_moyenne():.2f}")

    print("\nSupprimer 'Pizza' du menu.")
    # Supprimer le plat pizza du menu
    restaurant.remove_plat("Pizza")
    print("\nMenu actualisé:")
    # Afficher les plats du menu mis à jour et leur prix
    restaurant.afficher_menu()

Sortie:

Menu: Plats et prix
Bœuf à la ficelle: 15.00€
Pizza: 8,99€
Salade: 5.0€
Note moyenne pour Pizza: 3.5
Note moyenne pour Salad: 2
Note moyenne: 3.56987155
Supprimer 'Pizza' du menu.

Menu actualisé:
Bœuf à la ficelle: 15.00€
Salade: 5.0€

# Définir la classe CompteBancaire
class CompteBancaire:
    def __init__(self, num_compte, titulaire_compte, solde_initial):
        # Initialiser le numéro de compte
        self.num_compte = num_compte  
        # Initialiser le nom du titulaire du compte
        self.titulaire_compte = titulaire_compte  
        # Initialiser le solde du compte
        self.solde = solde_initial  

    # Méthode pour déposer de l'argent sur le compte
    def deposer(self, montant):
        if montant > 0:
            self.solde += montant
            print(f"Déposés: {montant}. Nouveau solde: {self.solde}")
        else:
            print("Le montant déposé doit être positif.")

    # Méthode pour retirer de l'argent du compte
    def retirer(self, montant):
        if montant > 0 and montant <= self.solde:
            self.solde -= montant
            print(f"Retrait: {montant}. Nouveau solde: {self.solde}")
        else:
            print("Solde insuffisant ou montant invalide.")

    # Méthode pour vérifier le solde du compte
    def check_solde(self):
        return self.solde

    # Méthode pour récupérer le numéro de compte
    def get_num_compte(self):
        return self.num_compte

    # Méthode pour récupérer le nom du titulaire du compte
    def get_titulaire_compte(self):
        return self.titulaire_compte


# Définir la classe CompteEpargne qui hérite de CompteBancaire
class CompteEpargne(CompteBancaire):
    def __init__(self, num_compte, titulaire_compte, solde_initial, taux_inter):
        # Appeler le constructeur de la classe mère
        super().__init__(num_compte, titulaire_compte, solde_initial) 
        # Initialiser le taux d'intérêt		
        self.taux_inter = taux_inter  

    # Méthode pour appliquer l'intérêt au solde
    def appliquer_inter(self):
        # Calculer l'intérêt
        inter = self.check_solde() * self.taux_inter / 100 
        # Ajouter de l'intérêt au solde		
        self.deposer(inter)  
        print(f"Intérêts appliqués: {inter}. Nouveau solde: {self.check_solde()}")

    # Méthode Getter pour le taux d'intérêt
    def get_taux_inter(self):
        return self.taux_inter

    # Méthode Setter pour le taux d'intérêt
    def set_taux_inter(self, taux_inter):
        if taux_inter > 0:
            self.taux_inter = taux_inter
        else:
            print("Le taux d'intérêt doit être positif.")


# Définir la classe Main
if __name__ == "__main__":
    # Créer un objet CompteBancaire
    cpt = CompteBancaire("902456001", "Alex Babtise", 1500.0)
    # Vérifier le solde
    print(f"Solde actuel: {cpt.check_solde()}")

    cpt.deposer(4000.0)  # Déposer de l'argent
    cpt.retirer(3000.0)  # Retirer de l'argent
    # Vérifier le solde
    print(f"Solde actuel: {cpt.check_solde()}")

    # Créer un objet CompteEpargne
    epargne = CompteEpargne("555236123", "Emily Leona", 3000.0, 5.0)
    # Appliquer l'intérêt
    epargne.appliquer_inter()

    # Vérifier le solde
    print(f"Compte d'épargne solde: {epargne.check_solde()}")

Sortie:

Solde actuel: 1500.0
Déposés: 4000.0. Nouveau solde: 5500.0
Retrait: 3000.0. Nouveau solde: 2500.0
Solde actuel: 2500.0
Déposés: 150.0. Nouveau solde: 3150.0
Intérêts appliqués: 150.0. Nouveau solde: 3150.0
Compte d'épargne solde: 3150.0

# Définir la classe Vehicule
class Vehicule:  
    def __init__(self, marque, model, an):
        # Initialiser la marque du véhicule
        self.marque = marque
        # Initialiser le modèle du véhicule		
        self.model = model  
        # Initialiser l'année du véhicule
        self.an = an  

    # Méthode pour afficher les détails du véhicule
    def afficher_details(self):
        print("Les détails du véhicule:")
        print(f"Marque: {self.marque}")
        print(f"Modèle: {self.model}")
        print(f"Année: {self.an}")

    # Méthode Getter pour la marque du véhicule
    def get_marque(self):
        return self.marque

    # Méthode Getter pour le modèle du véhicule
    def get_model(self):
        return self.model

    # Méthode Getter pour l'année du véhicule
    def get_an(self):
        return self.an


# Définir la classe Voiture qui hérite de Vehicule
class Voiture(Vehicule):
    def __init__(self, marque, model, an, taille_coffre):
        # Appeler le constructeur de la classe mère
        super().__init__(marque, model, an)  
        # Initialiser la taille du coffre
        self.taille_coffre = taille_coffre  

    # Surcharger la méthode afficher_details pour inclure la taille 
    # du coffre
    def afficher_details(self):
        # Appeler la méthode de la classe mère
        super().afficher_details()  
        print(f"Taille du coffre: {self.taille_coffre} mètres cubes")

    # Méthode pour récupérer la taille du coffre
    def get_taille_coffre(self):
        return self.taille_coffre

    # Méthode pour définir la taille du coffre
    def set_taille_coffre(self, taille_coffre):
        if taille_coffre > 0:
            self.taille_coffre = taille_coffre
        else:
            print("La taille du coffre doit être positive.")


# Définir la classe Camion qui hérite de Vehicule
class Camion(Vehicule):
    def __init__(self, marque, model, an, capacit_charge):
        # Appeler le constructeur de la classe mère
        super().__init__(marque, model, an)  
        # Initialiser la capacité de charge
        self.capacit_charge = capacit_charge  

    # Surcharger la méthode afficher_details pour inclure la capacité 
    # de charge
    def afficher_details(self):
        # Appeler la méthode de la classe mère
        super().afficher_details()  
        print(f"Capacité de charge: {self.capacit_charge} tons")

    # Méthode pour récupérer la capacité de charge
    def get_capacit_charge(self):
        return self.capacit_charge

    # Méthode pour définir la capacité de charge
    def set_capacit_charge(self, capacit_charge):
        if capacit_charge > 0:
            self.capacit_charge = capacit_charge
        else:
            print("La capacité de charge doit être positive.")


# Définir la classe Main
if __name__ == "__main__":
    # Créer un objet Voiture
    v = Voiture("BMW", "Série 6", 2014, 16.15)
    v.afficher_details()  # Afficher les détails de la voiture

    # Créer un objet Camion
    c = Camion("Mercedes", "Arocs", 2024, 4.5)
    c.afficher_details()  # Afficher les détails du camion

Sortie:

Les détails du véhicule:
Marque: BMW
Modèle: Série 6
Année: 2014
Taille du coffre: 16.15 mètres cubes
Les détails du véhicule:
Marque: Mercedes
Modèle: Arocs
Année: 2024
Capacité de charge: 4.5 tons

# Définir la classe Client
class Client:
    # Initialiser le nom, l'email et l'historique des achats du 
    # client
    def __init__(self, nom, email):
        self.nom = nom  # Nom du client
        self.email = email  # Email du client
        # Initialiser l'historique des achats comme une liste vide
        self.historique_achats = []

    # Méthode pour ajouter un achat à l'historique des achats
    def add_achat(self, montant):
        self.historique_achats.append(montant)

    # Méthode de calcul des dépenses totales
    def calculer_total_depenses(self):
        # Faire la somme des montants
        total = sum(self.historique_achats)  
        return total

    # Getters pour l'attribut nom
    def get_nom(self):
        return self.nom

    # Getters pour l'attribut email
    def get_email(self):
        return self.email

    # Méthode pour récupérer l'historique des achats
    def get_historique_achats(self):
        return self.historique_achats


# Définir la classe ClientFidele qui hérite de Client
class ClientFidele(Client):
    def __init__(self, nom, email, taux_remise):
        # Appeler le constructeur de la classe mère
        super().__init__(nom, email) 
        # Initialiser le taux de remise		
        self.taux_remise = taux_remise  

    # Méthode pour appliquer la réduction à un montant donné
    def appliquer_remise(self, montant):
        return montant - (montant * self.taux_remise / 100)

    # Surcharger la méthode add_achat pour appliquer la réduction 
    # avant d'ajouter l'achat
    def add_achat(self, montant):
        montant_reduit = self.appliquer_remise(montant)
		# Appeler la méthode de la classe mère
        super().add_achat(montant_reduit)  

    # Méthode pour récupérer le taux de remise
    def get_taux_remise(self):
        return self.taux_remise

    # Méthode pour définir le taux de remise
    def set_taux_remise(self, taux_remise):
        self.taux_remise = taux_remise


# Définir la classe Main
if __name__ == "__main__":
    # Créer un client régulier
    c = Client("Alex Rio", "alex@mail.com")
    c.add_achat(200)
    c.add_achat(300)
    print(f"Dépenses totales pour {c.get_nom()}: {c.calculer_total_depenses()}")

    # Créer un client fidèle avec un taux de réduction de 5%
    f = ClientFidele("Emily Bazi", "emily@mail.com", 5)

    f.add_achat(200)
    f.add_achat(300)
    print(f"Dépenses totales pour {f.get_nom()} après réduction: {f.calculer_total_depenses()}")

Sortie:

Dépenses totales pour Alex Rio: 500.0
Dépenses totales pourr Emily Bazi après réduction: 475.0