La Programmation Orientée Objet (POO) avec Python

class Livre:
    """Représente un livre avec un titre, un auteur et un statut."""
    def __init__(self, titre, auteur):
        self.titre = titre
        self.auteur = auteur
        self.est_emprunte = False
        
    def __str__(self):
    
        # utilisation de condition normale 
        # if self.est_emprunte:
            # statut = "Emprunté"
        # else:
            # statut = "Disponible"
    
        # affectation conditionnelle au lieu de la condition if normale 
        # statut = "Emprunté" if self.est_emprunte else "Disponible"
        return f"'{self.titre}' par {self.auteur} - Statut : {statut}"

class Bibliotheque:
    """Gère une collection de livres."""
    def __init__(self, nom):
        self.nom = nom
        self.__catalogue = [] # La liste des livres est privée

    def ajouter_livre(self, livre):
        self.__catalogue.append(livre)
        print(f"'{livre.titre}' a été ajouté au catalogue.")
            
    def lister_livres(self):
        print(f"\n--- Livres dans la bibliothèque '{self.nom}' ---")
        for livre in self.__catalogue:
            print(livre)
    
    def emprunter_livre(self, titre):
        for livre in self.__catalogue:
            if livre.titre == titre:
                if not livre.est_emprunte:
                    livre.est_emprunte = True
                    print(f"Vous avez emprunté '{titre}'.")
                else:
                    print(f"Désolé, '{titre}' est déjà emprunté.")
                return
        print(f"Le livre '{titre}' n'a pas été trouvé dans notre catalogue.")

    def retourner_livre(self, titre):
        for livre in self.__catalogue:
            if livre.titre == titre:
                livre.est_emprunte = False
                print(f"Merci d'avoir retourné '{titre}'.")
                return

# --- Programme principal ---
ma_biblio = Bibliotheque("Bibliothèque Municipale")

ma_biblio.ajouter_livre(Livre("L'Étranger", "Albert Camus"))
ma_biblio.ajouter_livre(Livre("1984", "George Orwell"))

ma_biblio.lister_livres()

ma_biblio.emprunter_livre("1984")
ma_biblio.emprunter_livre("Livre Inconnu")
ma_biblio.emprunter_livre("1984") # Essayer d'emprunter un livre déjà pris

ma_biblio.lister_livres() # Montre le changement de statut

ma_biblio.retourner_livre("1984")
ma_biblio.lister_livres() # Le livre est de nouveau disponible

class Etudiant:
    """
    Représente un étudiant avec ses notes.
    """
    def __init__(self, nom, prenom, niveau):
        self.nom = nom
        self.prenom = prenom
        self.niveau = niveau
        self.notes = {} # {matiere: note}

    def ajouter_note(self, matiere, note):
        """
        Ajoute ou met à jour la note pour une matière donnée.
        """
        if isinstance(note, (int, float)) and 0 <= note <= 20:
            self.notes[matiere] = note
        else:
            print(f"Note invalide: {note} doit être entre 0 et 20.")

    def calculer_moyenne(self):
        """
        Retourne la moyenne des notes de l'étudiant.
        """
        if not self.notes:
            return 0.0

        # solution élégante avec les listes des compréhensions
        # return sum([note for note in self.notes.values()]) / len(self.notes)

        # Accumulation sans listes de compréhension
        somme_notes = 0
        nombre_notes = 0
        
        for note in self.notes.values():
            somme_notes += note
            nombre_notes += 1
            
        return somme_notes / nombre_notes

    def __str__(self):
        moyenne = self.calculer_moyenne()
        return f"Etudiant: {self.prenom} {self.nom}, Niveau: {self.niveau}, Moyenne: {moyenne:.2f}"
    
class Classe:
    """
    Gère un groupe d'étudiants.
    """
    def __init__(self, nom_classe):
        self.nom_classe = nom_classe
        self.liste_etudiants = [] # Liste d'objets Etudiant

    def ajouter_etudiant(self, etudiant):
        """
        Ajoute un objet Etudiant à la liste de la classe.
        """
        if isinstance(etudiant, Etudiant):
            self.liste_etudiants.append(etudiant)
        else:
            print("Erreur: L'objet ajouté n'est pas un Etudiant valide.")

    def moyenne_classe(self):
        """
        Calcule la moyenne des moyennes de tous les étudiants.
        """
        if not self.liste_etudiants:
            return 0.0
        # solution élégante avec les listes des compréhensions
        # return sum([e.calculer_moyenne() for e in self.liste_etudiants]) / len(self.liste_etudiants)
 



        # Accumulation sans listes de compréhension
        somme_moyennes = 0.0
        nombre_etudiants = 0
        
        for etudiant in self.liste_etudiants:
            somme_moyennes += etudiant.calculer_moyenne()
            nombre_etudiants += 1
            
        return somme_moyennes / nombre_etudiants

    def meilleur_etudiant(self):
        """
        Affiche l'étudiant avec la meilleure moyenne.
        """
        if not self.liste_etudiants:
            print(f"La classe {self.nom_classe} est vide.")
            return None

        # solution élégante avec les listes des compréhensions
        # meilleur_etudiant = max(self.liste_etudiants, key=lambda e: e.calculer_moyenne())
        meilleur_etudiant = None
        meilleure_moyenne = -1 # Initialisation à une valeur impossible

        # Itération et comparaison explicite
        for etudiant in self.liste_etudiants:
            moyenne_actuelle = etudiant.calculer_moyenne()
            
            if moyenne_actuelle > meilleure_moyenne:
                meilleure_moyenne = moyenne_actuelle
                meilleur_etudiant = etudiant
        
        print(f"\n--- Meilleur étudiant de la classe {self.nom_classe} ---")
        print(meilleur_etudiant)
        print("-----------------------------------------------------")
        return meilleur_etudiant
    

# Création des étudiants
e1 = Etudiant("Hassani", "youssef", "TS")
e2 = Etudiant("karimi", "Amal", "TS")

# Ajout des notes
e1.ajouter_note("Maths", 15.5)
e1.ajouter_note("Physique", 17.0)
e2.ajouter_note("Maths", 10.0)
e2.ajouter_note("Physique", 12.5)

# Test des moyennes individuelles
print(f"Moyenne de Youssef: {e1.calculer_moyenne():.2f}") 
print(f"Moyenne de Amal: {e2.calculer_moyenne():.2f}") 

# Création et gestion de la classe
classe_TS = Classe("Terminale S - A")
classe_TS.ajouter_etudiant(e1)
classe_TS.ajouter_etudiant(e2)

# Test des statistiques de classe
print(f"\nMoyenne générale de la classe : {classe_TS.moyenne_classe():.2f}")

classe_TS.meilleur_etudiant()

class Produit:
    """
    Représente un produit avec son nom, son prix unitaire et sa quantité en stock.
    """
    def __init__(self, nom, prix, quantite_en_stock):
        """Initialise les attributs du produit."""
        self.nom = nom
        self.prix = prix
        # Assure que le stock initial est non négatif
        self.quantite_en_stock = max(0, quantite_en_stock) 

    def approvisionner(self, quantite):
        """
        Ajoute la quantité spécifiée au stock.
        """
        if quantite > 0:
            self.quantite_en_stock += quantite
            print(f"Stock de {self.nom} mis à jour : +{quantite}. Nouveau stock : {self.quantite_en_stock}")
        else:
            print("Erreur : La quantité d'approvisionnement doit être positive.")

    def vendre(self, quantite):
        """
        Réduit le stock si la quantité est disponible.
        Retourne True si la vente est réussie, False sinon.
        """
        if quantite <= 0:
            print("Erreur : La quantité vendue doit être positive.")
            return False
            
        if self.quantite_en_stock >= quantite:
            self.quantite_en_stock -= quantite
            montant_vente = quantite * self.prix
            print(f"Vente de {quantite} unités de {self.nom} réussie. Montant : {montant_vente:.2f}€. Stock restant : {self.quantite_en_stock}")
            return True
        else:
            print(f"Vente échouée pour {self.nom} : stock insuffisant ({self.quantite_en_stock} disponibles, {quantite} demandés).")
            return False

    def __str__(self):
        """Permet un affichage lisible du produit."""
        return f"Produit: {self.nom} | Prix: {self.prix:.2f}€ | Stock: {self.quantite_en_stock}"
    

class Magasin:
    """
    Représente un magasin gérant un catalogue de produits.
    """
    def __init__(self, nom, adresse):
        """Initialise le magasin."""
        self.nom = nom
        self.adresse = adresse
        self.catalogue = [] # Liste d'objets Produit

    def ajouter_produit(self, produit):
        """
        Ajoute un objet Produit au catalogue du magasin.
        """
        if isinstance(produit, Produit):
            self.catalogue.append(produit)
            print(f"Produit '{produit.nom}' ajouté au catalogue de {self.nom}.")
        else:
            print("Erreur : L'objet à ajouter n'est pas un Produit valide.")

    def rechercher_produit(self, nom):
        """
        Recherche un produit par son nom dans le catalogue.
        Utilise une boucle 'for' simple.
        Retourne l'objet Produit s'il est trouvé, None sinon.
        """
        nom_recherche = nom.lower()
        #  Liste de compréhension + next()
        # produit = next(
        #     (p for p in self.catalogue if p.nom.lower() == nom_recherche),
        #     None
        # )


        # Parcours du catalogue avec une boucle ordinaire
        for produit in self.catalogue:
            if produit.nom.lower() == nom_recherche:
                print(f"Produit trouvé : {produit}")
                return produit
                
        print(f"Produit '{nom}' non trouvé dans le catalogue.")
        return None

    def generer_rapport_stock(self):
        """
        Affiche un rapport détaillé sur l'état des stocks.
        Utilise une boucle 'for' simple pour l'affichage.
        """
        print(f"\n======== RAPPORT DE STOCK POUR {self.nom.upper()} ========")
        print(f"Localisation : {self.adresse}")
        
        # Affichage direct avec une liste de compréhension (pour l’itération)
        #[
        #    print(f"* {p.nom.ljust(20)} | Quantité: {p.quantite_en_stock} | Prix: {p.prix:.2f}€")
        #    for p in self.catalogue
        #]



        # Variables pour le résumé (calculé avec une boucle)
        nombre_total_produits = 0
        valeur_totale_stock = 0.0

        # Boucle ordinaire pour itérer sur le catalogue et générer le rapport
        for produit in self.catalogue:
            # Affichage du détail
            print(f"* {produit.nom.ljust(20)} | Quantité: {produit.quantite_en_stock} | Prix: {produit.prix:.2f}€")
            
            # Calcul du résumé
            nombre_total_produits += 1
            valeur_totale_stock += produit.quantite_en_stock * produit.prix
            
        print("--------------------------------------------------")
        print(f"Total de produits différents : {nombre_total_produits}")
        print(f"Valeur totale estimée du stock : {valeur_totale_stock:.2f}€")
        print("==================================================\n")

    def __str__(self):
        return f"Magasin : {self.nom} situé à {self.adresse}. Catalogue contient {len(self.catalogue)} produits différents."


# 1. Création et gestion des produits
pomme = Produit("Pomme", 0.50, 100)
lait = Produit("Lait", 1.20, 50)
pain = Produit("Pain", 2.00, 20)

print("--- Tests de la classe Produit ---")
pomme.vendre(10)      # Vente réussie
lait.vendre(60)       # Vente échouée (stock insuffisant)
pomme.approvisionner(20)
print(pomme)          # Affichage du stock mis à jour

print("\n--- Tests de la classe Magasin ---")
# 2. Création et gestion du magasin
mon_magasin = Magasin("Epicerie du Coin", "12 Rue Principale")
mon_magasin.ajouter_produit(pomme)
mon_magasin.ajouter_produit(lait)
mon_magasin.ajouter_produit(pain)

# 3. Recherche de produit
produit_trouve = mon_magasin.rechercher_produit("Lait")
produit_introuvable = mon_magasin.rechercher_produit("Pâtes")

# 4. Génération du rapport
mon_magasin.generer_rapport_stock()