img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python - Programmation orientée objet
Chapitre 3 : L'Encapsulation en Python : Protéger vos données

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é.

1. Introduction à l'encapsulation

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.

1.1 Qu'est-ce que l'encapsulation ?

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_encapsulation.py
# 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")

1.2 Pourquoi l'encapsulation est-elle importante ?

L'encapsulation offre plusieurs avantages cruciaux pour le développement de logiciels robustes et maintenables :

importance_encapsulation.py
# 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()

1.3 L'encapsulation dans le contexte de Python

Python adopte une approche particulière de l'encapsulation, basée sur des conventions plutôt que des restrictions strictes :

encapsulation_python.py
# 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}")

2. Les attributs en Python

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.

2.1 Attributs publics

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.

attributs_publics.py
# 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}")

2.2 Attributs protégés (convention _)

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.

attributs_proteges.py
# 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()

2.3 Attributs privés (convention __)

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.

attributs_prives.py
# 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()

2.4 Le name mangling en Python

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.

name_mangling.py
# 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()

3. Les méthodes et l'encapsulation

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.

3.1 Méthodes publiques

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.

methodes_publiques.py
# 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}")

3.2 Méthodes protégées

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.

methodes_protegees.py
# 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()

3.3 Méthodes privées

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.

methodes_privees.py
# 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}")

3.4 Bonnes pratiques pour les méthodes

Voici les meilleures pratiques pour l'encapsulation des méthodes en Python, illustrées par des exemples concrets dans un contexte marocain.

bonnes_pratiques_methodes.py
# 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")
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python - Programmation orientée objet | Allez au cours gratuits