Comprendre les principes de l'encapsulation et son importance dans la programmation orientée objet. Maîtriser l'utilisation des attributs privés, des méthodes protégées et des propriétés Python pour contrôler l'accès aux données. Appliquer les bonnes pratiques d'encapsulation dans des projets concrets pour créer du code maintenable et sécurisé.
L'encapsulation est un concept fondamental de la programmation orientée objet qui permet de regrouper les données et les méthodes qui les manipulent au sein d'une même entité, tout en contrôlant l'accès à ces données.
L'encapsulation consiste à cacher l'état interne d'un objet et à n'autoriser son accès qu'à travers des méthodes spécifiques. Cela permet de protéger l'intégrité des données et de simplifier l'utilisation de l'objet.
# Exemple d'une classe sans encapsulation class ClientMarocain: def __init__(self, nom, prenom): self.nom = nom # Attribut public - accessible directement self.prenom = prenom self.solde = 0 # Problème: on peut modifier le solde directement # Utilisation (problématique) client1 = ClientMarocain("Alaoui", "Fatima") client1.solde = 1000 # Modification directe non contrôlée client1.solde = -500 # Incohérence métier possible # Exemple avec encapsulation class ClientMarocainEncapsule: def __init__(self, nom, prenom): self.nom = nom # Reste public car pas de sensibilité self.prenom = prenom self._solde = 0 # Attribut protégé (convention) # Méthode pour accéder au solde (getter) def get_solde(self): return self._solde # Méthode pour modifier le solde (setter) avec validation def set_solde(self, montant): if montant >= 0: # Validation métier self._solde = montant else: print("Erreur: Le solde ne peut pas être négatif") # Utilisation correcte avec encapsulation client2 = ClientMarocainEncapsule("Benjelloun", "Mehdi") client2.set_solde(1000) # Modification contrôlée client2.set_solde(-500) # Rejeté par la validation print(f"Solde de {client2.prenom} {client2.nom}: {client2.get_solde()} DH")
L'encapsulation offre plusieurs avantages cruciaux pour le développement de logiciels robustes et maintenables :
# Exemple démontrant les avantages de l'encapsulation class CompteBancaireMarocain: def __init__(self, titulaire, solde_initial=0): self.titulaire = titulaire # Public self._solde = solde_initial # Protégé self._historique = [] # Privé (convention) # AVANTAGE 1: Contrôle des accès et validation def deposer(self, montant): if montant > 0: self._solde += montant self._ajouter_operation(f"Dépôt: +{montant} DH") print(f"{montant} DH déposés avec succès.") else: print("Le montant doit être positif") # AVANTAGE 2: Abstraction et simplification d'utilisation def retirer(self, montant): if 0 < montant <= self._solde: self._solde -= montant self._ajouter_operation(f"Retrait: -{montant} DH") print(f"{montant} DH retirés avec succès.") else: print("Opération impossible: solde insuffisant ou montant invalide") # AVANTAGE 3: Maintenance et évolution facilitées def get_solde(self): return self._solde # Méthode interne (détail d'implémentation caché) def _ajouter_operation(self, operation): self._historique.append(operation) # AVANTAGE 4: Interface cohérente def afficher_historique(self): print(f"\nHistorique des opérations de {self.titulaire}:") for op in self._historique: print(f"- {op}") print(f"Solde actuel: {self._solde} DH") # Utilisation compte = CompteBancaireMarocain("Karim Amrani") compte.deposer(5000) compte.retirer(2000) compte.retirer(4000) # Devrait échouer compte.afficher_historique()
Python adopte une approche particulière de l'encapsulation, basée sur des conventions plutôt que des restrictions strictes :
# Python utilise des conventions pour l'encapsulation class EntrepriseMarocaine: def __init__(self, nom, ville): self.nom = nom # Public - accessible à tous self._ville = ville # Protégé - convention pour usage interne self.__chiffre_affaires = 0 # Privé - name mangling appliqué # Méthode publique def afficher_infos(self): print(f"Entreprise: {self.nom}, Ville: {self._ville}") # Méthode protégée (convention) def _calculer_impots(self): # Méthode destinée à un usage interne ou aux sous-classes return self.__chiffre_affaires * 0.25 # Taux d'imposition marocain # Méthode privée (name mangling) def __gerer_finances(self): # Méthode vraiment interne à la classe print("Gestion des finances interne...") # Property pour accéder au chiffre d'affaires de manière contrôlée @property def chiffre_affaires(self): return self.__chiffre_affaires @chiffre_affaires.setter def chiffre_affaires(self, valeur): if valeur >= 0: self.__chiffre_affaires = valeur else: print("Le chiffre d'affaires ne peut pas être négatif") # Utilisation des différents niveaux d'encapsulation entreprise = EntrepriseMarocaine("Maroc Telecom", "Rabat") # Accès public - OK print(entreprise.nom) # Accès direct autorisé entreprise.afficher_infos() # Méthode publique # Accès protégé - Possible mais déconseillé (convention) print(entreprise._ville) # Accès possible mais indicateur d'usage interne # Accès privé - Renommé par Python (name mangling) # print(entreprise.__chiffre_affaires) # Erreur: AttributeError print(entreprise._EntrepriseMarocaine__chiffre_affaires) # Accès technique possible mais fortement déconseillé # Utilisation correcte via les properties entreprise.chiffre_affaires = 1000000 # Utilisation du setter print(f"Chiffre d'affaires: {entreprise.chiffre_affaires} DH") # Utilisation du getter # Démonstration du name mangling print("\nAttributs de l'instance:") for attr in dir(entreprise): if not attr.startswith('__'): print(f"- {attr}")
En Python, les attributs d'une classe peuvent avoir différents niveaux de visibilité et d'accessibilité, contrôlés par des conventions de nommage plutôt que par des mots-clés stricts comme dans d'autres langages.
Les attributs publics sont accessibles directement depuis l'extérieur de la classe, sans restriction. C'est le niveau d'encapsulation par défaut en Python.
# Exemple d'attributs publics dans une classe marocaine class UniversiteMarocaine: def __init__(self, nom, ville): self.nom = nom # Attribut public self.ville = ville # Attribut public self.nombre_etudiants = 0 # Attribut public def ajouter_etudiants(self, nombre): self.nombre_etudiants += nombre # Utilisation des attributs publics um5 = UniversiteMarocaine("Université Mohammed V", "Rabat") # Accès direct aux attributs publics print(f"Nom: {um5.nom}") print(f"Ville: {um5.ville}") print(f"Nombre d'étudiants: {um5.nombre_etudiants}") # Modification directe des attributs publics um5.nom = "UM5-Rabat" um5.nombre_etudiants = 25000 print(f"\nAprès modification:") print(f"Nom: {um5.nom}") print(f"Nombre d'étudiants: {um5.nombre_etudiants}") # Utilisation de la méthode pour modifier l'attribut um5.ajouter_etudiants(5000) print(f"\nAprès ajout via méthode: {um5.nombre_etudiants}")
Les attributs protégés sont indiqués par un préfixe underscore (_). C'est une convention qui signale que l'attribut est destiné à un usage interne à la classe ou à ses sous-classes, mais Python n'empêche pas son accès direct.
# Exemple d'attributs protégés dans une classe marocaine class HotelMarocain: def __init__(self, nom, ville, etoiles): self.nom = nom # Public self.ville = ville # Public self._etoiles = etoiles # Protégé (convention) self._chambres_occupees = 0 # Protégé self._taux_occupation = 0.0 # Protégé def reserver_chambre(self, nombre=1): if nombre > 0: self._chambres_occupees += nombre self._calculer_taux_occupation() print(f"{nombre} chambre(s) réservée(s) à l'hôtel {self.nom}") def liberer_chambre(self, nombre=1): if 0 < nombre <= self._chambres_occupees: self._chambres_occupees -= nombre self._calculer_taux_occupation() print(f"{nombre} chambre(s) libérée(s) de l'hôtel {self.nom}") def _calculer_taux_occupation(self): # Méthode protégée pour calcul interne capacite_totale = 100 # Capacité fixe pour l'exemple self._taux_occupation = (self._chambres_occupees / capacite_totale) * 100 def afficher_statistiques(self): print(f"\nStatistiques de l'hôtel {self.nom} ({self.ville}):") print(f"Étoiles: {self._etoiles}") print(f"Chambres occupées: {self._chambres_occupees}") print(f"Taux d'occupation: {self._taux_occupation:.1f}%") # Utilisation hotel = HotelMarocain("La Mamounia", "Marrakech", 5) hotel.reserver_chambre(30) hotel.reserver_chambre(25) hotel.afficher_statistiques() # Accès aux attributs protégés (possible mais déconseillé) print(f"\nAccès direct aux attributs protégés (déconseillé):") print(f"Étoiles: {hotel._etoiles}") print(f"Chambres occupées: {hotel._chambres_occupees}") # Modification directe des attributs protégés (déconseillé) hotel._chambres_occupees = 80 # Contourne la logique de validation hotel._taux_occupation = 80.0 # Contourne le calcul automatique hotel.afficher_statistiques()
Les attributs privés sont indiqués par un double préfixe underscore (__). Python applique le "name mangling" pour rendre l'accès plus difficile depuis l'extérieur de la classe, mais il reste techniquement possible.
# Exemple d'attributs privés dans une classe marocaine class CompteBancaireMarocain: def __init__(self, titulaire, solde_initial=0): self.titulaire = titulaire # Public self.__solde = solde_initial # Privé (name mangling) self.__code_secret = "0000" # Très privé self.__historique_transactions = [] # Privé def deposer(self, montant): if montant > 0: self.__solde += montant self.__ajouter_historique(f"Dépôt: +{montant} DH") print(f"{montant} DH déposés avec succès. Nouveau solde: {self.__solde} DH") else: print("Le montant doit être positif") def retirer(self, montant, code): if not self.__verifier_code(code): print("Code secret incorrect") return if 0 < montant <= self.__solde: self.__solde -= montant self.__ajouter_historique(f"Retrait: -{montant} DH") print(f"{montant} DH retirés avec succès. Nouveau solde: {self.__solde} DH") else: print("Opération impossible: solde insuffisant ou montant invalide") def afficher_solde(self): print(f"Solde actuel: {self.__solde} DH") def changer_code(self, ancien_code, nouveau_code): if self.__verifier_code(ancien_code): self.__code_secret = nouveau_code print("Code secret modifié avec succès") else: print("Ancien code incorrect") def __verifier_code(self, code): # Méthode privée pour vérification interne return code == self.__code_secret def __ajouter_historique(self, operation): # Méthode privée pour gestion interne de l'historique self.__historique_transactions.append(operation) def afficher_historique(self, code): if not self.__verifier_code(code): print("Code secret incorrect") return print(f"\nHistorique des transactions de {self.titulaire}:") for op in self.__historique_transactions: print(f"- {op}") # Utilisation compte = CompteBancaireMarocain("Fatima Zahra", 5000) compte.deposer(2000) compte.retirer(1000, "0000") # Code correct compte.retirer(1000, "1234") # Code incorrect compte.afficher_solde() # Tentative d'accès direct aux attributs privés (génère une erreur) try: print(compte.__solde) # AttributeError: 'CompteBancaireMarocain' object has no attribute '__solde' except AttributeError as e: print(f"Erreur: {e}") # Accès via le name mangling (possible mais fortement déconseillé) print(f"\nAccès technique via name mangling (déconseillé):") print(f"Solde: {compte._CompteBancaireMarocain__solde} DH") # Modification directe via name mangling (très déconseillé) compte._CompteBancaireMarocain__solde = 10000 # Contourne toutes les validations compte.afficher_solde()
Le name mangling est un mécanisme Python qui renomme les attributs et méthodes préfixés par __ pour éviter les conflits de noms dans l'héritage et rendre l'accès plus difficile depuis l'extérieur.
# Démonstration du name mangling en Python class SocieteMarocaine: def __init__(self, nom): self.nom = nom # Public - pas de name mangling self._capital = 100000 # Protégé - pas de name mangling self.__benefices = 0 # Privé - name mangling appliqué self.__donnees_confidentielles = "secret" # Privé def ajouter_benefice(self, montant): self.__benefices += montant def __calculer_impots(self): # Méthode privée avec name mangling return self.__benefices * 0.3 # Taux d'imposition marocain # Création d'une instance societe = SocieteMarocaine("OCP Group") societe.ajouter_benefice(500000) # Inspection des attributs de l'instance print("Attributs de l'instance:") for attr in dir(societe): if not attr.startswith('__') or attr.endswith('__'): print(f"- {attr}") # Accès aux différents types d'attributs print(f"\nNom (public): {societe.nom}") print(f"Capital (protégé): {societe._capital}") # Tentative d'accès direct aux attributs privés (échoue) try: print(societe.__benefices) except AttributeError as e: print(f"Erreur accès __benefices: {e}") # Accès via le name mangling (possible) print(f"Bénéfices (via name mangling): {societe._SocieteMarocaine__benefices}") print(f"Données confidentielles: {societe._SocieteMarocaine__donnees_confidentielles}") # Appel d'une méthode privée via name mangling impots = societe._SocieteMarocaine__calculer_impots() print(f"Impôts à payer: {impots} DH") # Démonstration de l'utilité du name mangling dans l'héritage class Filiale(SocieteMarocaine): def __init__(self, nom, secteur): super().__init__(nom) self.secteur = secteur self.__benefices = 0 # N'écrase pas le __benefices de la classe parente def ajouter_benefice_filiale(self, montant): self.__benefices += montant def afficher_benefices(self): print(f"Bénéfices parent: {self._SocieteMarocaine__benefices}") print(f"Bénéfices filiale: {self.__benefices}") # Test de la filiale filiale = Filiale("OCP Phosphore", "Chimie") filiale.ajouter_benefice(100000) # Méthode parente - modifie _SocieteMarocaine__benefices filiale.ajouter_benefice_filiale(50000) # Méthode fille - modifie _Filiale__benefices filiale.afficher_benefices()
En Python, les méthodes d'une classe peuvent également avoir différents niveaux de visibilité, permettant de contrôler comment les fonctionnalités d'un objet sont exposées et utilisées.
Les méthodes publiques constituent l'interface principale d'une classe. Elles sont accessibles sans restriction et définissent comment les utilisateurs doivent interagir avec l'objet.
# Exemple de méthodes publiques dans une classe marocaine class RestaurantMarocain: def __init__(self, nom, ville, specialite): self.nom = nom self.ville = ville self.specialite = specialite self._plats_disponibles = [] # Attribut protégé self.__recettes_secretes = {} # Attribut privé # MÉTHODE PUBLIQUE: Ajouter un plat au menu def ajouter_plat(self, nom_plat, prix): if prix > 0: self._plats_disponibles.append({"nom": nom_plat, "prix": prix}) print(f"Plat '{nom_plat}' ajouté au menu pour {prix} DH") else: print("Le prix doit être positif") # MÉTHODE PUBLIQUE: Afficher le menu def afficher_menu(self): print(f"\nMenu du restaurant {self.nom} ({self.ville}):") print(f"Spécialité: {self.specialite}") for i, plat in enumerate(self._plats_disponibles, 1): print(f"{i}. {plat['nom']} - {plat['prix']} DH") # MÉTHODE PUBLIQUE: Commander un plat def commander(self, nom_plat, quantite=1): plat_trouve = None for plat in self._plats_disponibles: if plat["nom"].lower() == nom_plat.lower(): plat_trouve = plat break if plat_trouve: total = plat_trouve["prix"] * quantite print(f"Commande de {quantite} '{nom_plat}' - Total: {total} DH") self.__preparer_commande(nom_plat, quantite) # Appel méthode privée else: print(f"Plat '{nom_plat}' non disponible") # MÉTHODE PUBLIQUE: Obtenir des informations def get_info(self): return { "nom": self.nom, "ville": self.ville, "specialite": self.specialite, "nombre_plats": len(self._plats_disponibles) } # MÉTHODE PRIVÉE: Préparer la commande (détail d'implémentation) def __preparer_commande(self, plat, quantite): # Logique interne de préparation print(f"Préparation en cours de {quantite} portion(s) de {plat}...") # Utilisation des recettes secrètes if plat in self.__recettes_secretes: print(f"Application de la recette secrète pour {plat}") # Utilisation des méthodes publiques restaurant = RestaurantMarocain("Le Palais Marrakchi", "Marrakech", "Couscous") # Appel des méthodes publiques restaurant.ajouter_plat("Tajine poulet", 65) restaurant.ajouter_plat("Couscous royal", 80) restaurant.ajouter_plat("Pastilla", 70) restaurant.ajouter_plat("Harira", 25) restaurant.afficher_menu() restaurant.commander("Tajine poulet", 2) restaurant.commander("Harira", 4) # Utilisation de la méthode get_info info = restaurant.get_info() print(f"\nInformations du restaurant: {info}") # Tentative d'appel d'une méthode privée (échoue) try: restaurant.__preparer_commande("test", 1) except AttributeError as e: print(f"\nErreur: {e}")
Les méthodes protégées (préfixées par _) sont destinées à un usage interne à la classe ou à ses sous-classes. C'est une convention qui indique qu'elles ne font pas partie de l'API publique.
# Exemple de méthodes protégées dans une classe marocaine class ProduitArtisanalMarocain: def __init__(self, nom, type_artisanat, region): self.nom = nom self.type_artisanat = type_artisanat self.region = region self.__prix_fabrication = 0 # Coût de fabrication self._prix_vente = 0 # Prix de vente # MÉTHODE PUBLIQUE: Définir le prix de fabrication def set_prix_fabrication(self, prix): if prix >= 0: self.__prix_fabrication = prix self._calculer_prix_vente() # Appel méthode protégée else: print("Le prix de fabrication doit être positif") # MÉTHODE PROTÉGÉE: Calculer le prix de vente def _calculer_prix_vente(self): # Logique métier: marge de 40% + coût fixe selon le type d'artisanat marge = self.__prix_fabrication * 0.4 # Coûts fixes supplémentaires selon le type couts_fixes = { "poterie": 20, "tapis": 50, "cuir": 30, "bois": 25, "metal": 40 } cout_fixe = couts_fixes.get(self.type_artisanat.lower(), 15) self._prix_vente = self.__prix_fabrication + marge + cout_fixe # MÉTHODE PROTÉGÉE: Vérifier la qualité def _verifier_qualite(self): # Simulation de contrôle qualité import random qualite = random.choice(["excellente", "bonne", "moyenne"]) print(f"Qualité {qualite} pour le produit {self.nom}") return qualite # MÉTHODE PUBLIQUE: Obtenir le prix de vente def get_prix_vente(self): self._verifier_qualite() # Appel méthode protégée return round(self._prix_vente, 2) # MÉTHODE PUBLIQUE: Afficher les détails def afficher_details(self): print(f"\nProduit: {self.nom}") print(f"Type: {self.type_artisanat}") print(f"Région: {self.region}") print(f"Prix de vente: {self.get_prix_vente()} DH") # Utilisation tapis = ProduitArtisanalMarocain("Tapis Beni Ourain", "tapis", "Moyen Atlas") tapis.set_prix_fabrication(200) tapis.afficher_details() poterie = ProduitArtisanalMarocain("Vase Fès", "poterie", "Fès") poterie.set_prix_fabrication(80) poterie.afficher_details() # Accès aux méthodes protégées (possible mais déconseillé) print("\nAccès direct aux méthodes protégées (déconseillé):") qualite = tapis._verifier_qualite() print(f"Qualité obtenue directement: {qualite}") # Les méthodes protégées sont utiles pour l'héritage class ProduitDeLuxe(ProduitArtisanalMarocain): def _calculer_prix_vente(self): # Surcharge de la méthode protégée pour les produits de luxe super()._calculer_prix_vente() self._prix_vente *= 2 # Double le prix pour le luxe def _verifier_qualite(self): # Surcharge avec contrôle qualité plus strict print("Contrôle qualité de luxe en cours...") return "excellente" # Toujours excellente pour le luxe # Test de la sous-classe tapis_luxe = ProduitDeLuxe("Tapis de Luxe", "tapis", "Rabat") tapis_luxe.set_prix_fabrication(200) tapis_luxe.afficher_details()
Les méthodes privées (préfixées par __) sont destinées à un usage strictement interne à la classe. Python applique le name mangling pour rendre leur accès plus difficile depuis l'extérieur.
# Exemple de méthodes privées dans une classe marocaine class SystemeReservationHotel: def __init__(self, nom_hotel, ville): self.nom_hotel = nom_hotel self.ville = ville self._chambres_disponibles = 50 # Protégé self.__tarifs = { # Privé - données sensibles "standard": 400, "supérieure": 600, "suite": 1000, "royale": 2000 } self.__reservations = {} # Privé - données sensibles self.__dernier_id = 0 # MÉTHODE PUBLIQUE: Réserver une chambre def reserver(self, client, type_chambre, nuits): if self._chambres_disponibles <= 0: print("Désolé, complet !") return None if type_chambre not in self.__tarifs: print(f"Type de chambre '{type_chambre}' non disponible") return None # Utilisation de méthodes privées pour la logique interne reservation_id = self.__generer_id_reservation() total = self.__calculer_prix_sejour(type_chambre, nuits) self.__enregistrer_reservation(reservation_id, client, type_chambre, nuits, total) self._chambres_disponibles -= 1 print(f"Réservation #{reservation_id} confirmée pour {client}") print(f"Total: {total} DH pour {nuits} nuit(s)") return reservation_id # MÉTHODE PRIVÉE: Générer un ID de réservation def __generer_id_reservation(self): self.__dernier_id += 1 return str(self.__dernier_id).zfill(4) # MÉTHODE PRIVÉE: Calculer le prix du séjour def __calculer_prix_sejour(self, type_chambre, nuits): prix_nuit = self.__tarifs[type_chambre] total = prix_nuit * nuits # Application de remises if nuits >= 7: total *= 0.9 # 10% de réduction pour séjour longue durée elif nuits >= 3: total *= 0.95 # 5% de réduction return round(total) # MÉTHODE PRIVÉE: Enregistrer la réservation def __enregistrer_reservation(self, reservation_id, client, type_chambre, nuits, total): self.__reservations[reservation_id] = { "client": client, "type_chambre": type_chambre, "nuits": nuits, "total": total, "statut": "confirmée" } # MÉTHODE PUBLIQUE: Annuler une réservation def annuler_reservation(self, reservation_id): if reservation_id in self.__reservations: reservation = self.__reservations[reservation_id] reservation["statut"] = "annulée" self._chambres_disponibles += 1 print(f"Réservation #{reservation_id} annulée") # Application de frais d'annulation via méthode privée frais = self.__calculer_frais_annulation(reservation) if frais > 0: print(f"Frais d'annulation: {frais} DH") else: print(f"Réservation #{reservation_id} non trouvée") # MÉTHODE PRIVÉE: Calculer les frais d'annulation def __calculer_frais_annulation(self, reservation): # Politique d'annulation: 20% si annulation moins de 48h avant import random moins_de_48h = random.choice([True, False]) if moins_de_48h: return round(reservation["total"] * 0.2) return 0 # MÉTHODE PUBLIQUE: Afficher les statistiques def afficher_statistiques(self): confirmées = sum(1 for r in self.__reservations.values() if r["statut"] == "confirmée") annulées = sum(1 for r in self.__reservations.values() if r["statut"] == "annulée") print(f"\nStatistiques de l'hôtel {self.nom_hotel}:") print(f"Chambres disponibles: {self._chambres_disponibles}") print(f"Réservations confirmées: {confirmées}") print(f"Réservations annulées: {annulées}") # Utilisation du système de réservation hotel = SystemeReservationHotel("La Sultana", "Marrakech") # Réservations id1 = hotel.reserver("Ahmed Ziani", "supérieure", 5) id2 = hotel.reserver("Fatima Mekouar", "suite", 2) id3 = hotel.reserver("Karim Belhaj", "standard", 7) # Annulation hotel.annuler_reservation(id2) # Statistiques hotel.afficher_statistiques() # Tentative d'accès aux méthodes privées (échoue) try: hotel.__calculer_prix_sejour("standard", 3) except AttributeError as e: print(f"\nErreur accès méthode privée: {e}") # Accès via name mangling (déconseillé) tarifs = hotel._SystemeReservationHotel__tarifs print(f"\nTarifs (accès technique): {tarifs}")
Voici les meilleures pratiques pour l'encapsulation des méthodes en Python, illustrées par des exemples concrets dans un contexte marocain.
# Exemple de bonnes pratiques pour l'encapsulation des méthodes class GestionnaireProjetMarocain: def __init__(self, nom_projet, budget_initial): self.nom_projet = nom_projet self._budget = budget_initial # Protégé self.__depenses = [] # Privé self.__taux_avancement = 0 # Privé # BONNE PRATIQUE 1: Méthodes publiques comme interface claire def ajouter_depense(self, montant, description): """Ajoute une dépense au projet avec validation.""" if montant <= 0: print("Le montant doit être positif") return False if self._budget - montant < 0: print("Dépense refusée : budget insuffisant") return False self._budget -= montant self.__depenses.append({"montant": montant, "description": description}) # Mise à jour interne de l'avancement self.__mettre_a_jour_avancement() print(f"Dépense de {montant} DH ajoutée pour: {description}") return True # BONNE PRATIQUE 2: Méthodes protégées pour la logique interne partagée def _calculer_budget_restant(self): """Calcule le budget restant.""" total_depenses = sum(d["montant"] for d in self.__depenses) return self._budget # BONNE PRATIQUE 3: Méthodes privées pour les détails d'implémentation def __mettre_a_jour_avancement(self): """Met à jour le taux d'avancement en fonction des dépenses.""" budget_initial = 100000 # Simplification pour l'exemple total_depenses = sum(d["montant"] for d in self.__depenses) self.__taux_avancement = min(100, (total_depenses / budget_initial) * 100) # BONNE PRATIQUE 4: Properties pour l'accès contrôlé aux attributs @property def taux_avancement(self): """Retourne le taux d'avancement en pourcentage.""" return round(self.__taux_avancement, 1) # BONNE PRATIQUE 5: Méthodes pour obtenir des rapports def generer_rapport(self): """Génère un rapport détaillé du projet.""" budget_restant = self._calculer_budget_restant() total_depenses = sum(d["montant"] for d in self.__depenses) print(f"\n=== RAPPORT DU PROJET {self.nom_projet} ===") print(f"Budget restant: {budget_restant} DH") print(f"Total dépensé: {total_depenses} DH") print(f"Taux d'avancement: {self.taux_avancement}%") print("\nDétail des dépenses:") for i, depense in enumerate(self.__depenses, 1): print(f"{i}. {depense['description']}: {depense['montant']} DH") # BONNE PRATIQUE 6: Méthode statique pour les utilitaires @staticmethod def convertir_en_dollars(montant_dh): """Convertit un montant de DH en Dollars (taux fixe pour l'exemple).""" taux = 0.1 # 1 DH = 0.1 USD (exemple) return round(montant_dh * taux, 2) # BONNE PRATIQUE 7: Méthode de classe pour les constructeurs alternatifs @classmethod def projet_international(cls, nom_projet, budget_dollars): """Crée un projet avec un budget en dollars.""" budget_dh = budget_dollars * 10 # Conversion inverse print(f"Création du projet international: {budget_dollars} USD = {budget_dh} DH") return cls(nom_projet, budget_dh) # Utilisation des bonnes pratiques projet = GestionnaireProjetMarocain("Construction École Rurale", 100000) # Utilisation de l'interface publique projet.ajouter_depense(25000, "Matériaux de construction") projet.ajouter_depense(15000, "Mobilier scolaire") projet.ajouter_depense(10000, "Équipement informatique") # Génération du rapport projet.generer_rapport() # Utilisation de la méthode statique montant_dollars = GestionnaireProjetMarocain.convertir_en_dollars(50000) print(f"\n50 000 DH = {montant_dollars} USD") # Utilisation de la méthode de classe projet_international = GestionnaireProjetMarocain.projet_international( "Projet International", 5000 # 5000 USD ) projet_international.ajouter_depense(10000, "Frais internationaux") projet_international.generer_rapport() # Respect de l'encapsulation - pas d'accès direct aux attributs/méthodes privés print(f"\nTaux d'avancement via property: {projet.taux_avancement}%") # Tentative d'accès direct aux éléments privés (déconseillé) print(f"Budget via attribut protégé (déconseillé): {projet._budget} DH")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!