Exercice Corrigé: Les classes POO Python – Partie 7

Cet exercice de programmation orientée objet (POO) a pour but de vous aider à apprendre et à pratiquer les concepts de la POO. Toutes les questions sont testées sur Python 3.

Python La programmation orientée objet (POO) est basée sur le concept d’« objets », qui peuvent contenir des données et du code : des données sous la forme de variables d’instance (souvent connues sous le nom d’attributs ou de propriétés), et du code, sous la forme de méthodes. En d’autres termes, la POO permet d’encapsuler des propriétés et des comportements connexes dans des objets individuels.
 
 

Exercice 1:

Écrire un programme Python pour créer une classe appelée « Voyage » avec des méthodes permettant de rechercher des vols et des hôtels, ainsi que de réserver et d’annuler des réservations.

Diagrame de classe:

Solution:

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.
 

Exercice 2:

Écrivez un programme Python pour créer une classe appelée « Restaurant » avec des attributs pour les plats du menu, les prix et les notes, et des méthodes pour ajouter et supprimer des plats, et pour calculer la note moyenne.

Diagrame de classe:

Solution:

# 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€
 

Exercice 3:

Écrivez un programme Python pour créer une classe appelée « CompteBancaire » avec des attributs pour le numéro de compte, le nom du titulaire du compte et le solde. Incluez des méthodes pour déposer et retirer de l’argent, ainsi que pour vérifier le solde. Créez une classe fils appelée « CompteEpargne » qui ajoute un attribut de taux d’intérêt et une méthode pour appliquer l’intérêt.

Diagrame de classe:

Solution:

# 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
 

Exercice 4:

Écrire un programme Python pour créer une classe appelée « Vehicule » avec des attributs pour la marque, le modèle et l’année. Créez des classes fils « Voiture » et « Camion » qui ajoutent des attributs spécifiques tels que la taille du coffre pour les voitures et la capacité de charge pour les camions. Implémentez une méthode pour afficher les détails du véhicule dans chaque classe fille.

Diagrame de classe:

Solution:

# 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
 

Exercice 5:

Écrire un programme Python pour créer une classe appelée « Client » avec des attributs pour le nom, l’email et l’historique des achats. Implémentez des méthodes pour ajouter des achats à l’historique et calculer la dépense totale. Créez une classe fille « ClientFidele » qui ajoute un attribut de taux de remise et une méthode pour appliquer la remise.

Diagrame de classe:

Solution:

# 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", "[email protected]")
    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", "[email protected]", 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
 

Éditeur de code Python: Testez votre code en ligne!


 

QCM Python

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *