Modificateurs d'accès

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 29 sur 64.

Les modificateurs d'accès contrôlent la visibilité des attributs et des méthodes de classe. Python utilise des conventions de nommage plutôt que des mots-clés pour le contrôle d'accès.

Voici un exemple d'accès public (sans préfixe) :

class Person:
    def __init__(self):
        self.name = "Coddy"      # Attribut public
        
    def greet(self):             # Méthode publique
        return f"Hello, I'm {self.name}"

Accédez aux membres publics de n'importe où :

person = Person()
print(person.name)           # Coddy
print(person.greet())        # Bonjour, je suis Coddy

Voici un exemple d'accès protégé (souligné simple) :

class Employee:
    def __init__(self):
        self._salary = 50000     # Attribut protégé
    
    def _calculate_bonus(self):  # Méthode protégée
        return self._salary * 0.1

    def show_bonus(self):
        return self._calculate_bonus()  # Utilisation autorisée au sein de la classe

Accéder aux membres protégés (fonctionne mais n'est pas recommandé) :

employee = Employee()
print(employee._salary)      # 50000 - fonctionne mais déconseillé
print(employee.show_bonus()) # 5000.0 - la bonne manière

Voici un exemple d'accès privé (double souligné) :

class User:
    def __init__(self):
        self.__password = "secure123"   # Attribut privé
        
    def __encrypt(self, data):          # Méthode privée
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        # Membres privés accessibles à l'intérieur de la classe
        return input_password == self.__password

Utilisez correctement les membres privés :

user = User()
print(user.verify("secure123"))  # True - utilisation d'une méthode publique
# print(user.__password)         # AttributeError - impossible d'accéder directement

Sortie :

Coddy
Hello, I'm Coddy
50000
5000.0
True

Point clé : Les modificateurs d'accès Python sont des conventions de nommage : pas de préfixe = public (accessible partout), simple trait de soulignement = protégé (usage interne), double trait de soulignement = privé (classe uniquement). Ceux-ci aident à établir des limites claires et à prévenir une mauvaise utilisation accidentelle des éléments internes de la classe.

Défi

Moyen

Dans ce défi, vous allez implémenter une classe FileManager qui illustre les modificateurs d'accès de Python (public, protégé et privé) tout en découvrant les avantages de tests complets.

Modifiez filemanager.py pour implémenter la classe FileManager en suivant les commentaires TODO. Le fichier contient des instructions détaillées pour implémenter :

Des méthodes publiques pour les opérations sur les fichiers
Des méthodes protégées (avec un préfixe d'underscore simple)
Des méthodes privées (avec un préfixe de double underscore)
Des interactions entre méthodes illustrant l'encapsulation

Aide-mémoire

Python utilise des conventions de nommage pour le contrôle d'accès :

Accès public (pas de préfixe) - accessible partout :

class Person:
    def __init__(self):
        self.name = "Coddy"      # Attribut public
        
    def greet(self):             # Méthode publique
        return f"Hello, I'm {self.name}"

person = Person()
print(person.name)           # Coddy
print(person.greet())        # Hello, I'm Coddy

Accès protégé (souligné simple) - usage interne, déconseillé de l'extérieur :

class Employee:
    def __init__(self):
        self._salary = 50000     # Attribut protégé
    
    def _calculate_bonus(self):  # Méthode protégée
        return self._salary * 0.1

employee = Employee()
print(employee._salary)      # Fonctionne mais déconseillé

Accès privé (double souligné) - classe uniquement :

class User:
    def __init__(self):
        self.__password = "secure123"   # Attribut privé
        
    def __encrypt(self, data):          # Méthode privée
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        return input_password == self.__password

user = User()
print(user.verify("secure123"))  # True - utilise une méthode publique
# print(user.__password)         # AttributeError - impossible d'accéder directement

Essayez vous-même

from file_manager import FileManager

# Gestionnaire de cas de test complet
test_case = input()

if test_case == "basic_test":
    # Créer une instance de FileManager
    manager = FileManager()
    # Appeler la méthode read_file
    print(manager.read_file("example.txt"))
    # Appeler la méthode get_file_content
    print(manager.get_file_content("example.txt"))

elif test_case == "protected_access":
    # Créer une instance de FileManager
    manager = FileManager()
    # Essayer d'appeler la méthode protégée
    # Les méthodes protégées sont accessibles mais destinées à un usage interne
    print(manager._check_permissions("example.txt"))
    print("Note: Protected methods are accessible but intended for internal use only")

elif test_case == "private_access":
    # Créer une instance de FileManager
    manager = FileManager()
    try:
        # Essayer d'appeler la méthode privée directement
        print(manager.__decrypt_content("some content"))
    except AttributeError as e:
        print(f"Error: {e}")
        print("Private methods are name-mangled and cannot be accessed directly")
    
    # Accès en utilisant la forme "name-mangled"
    print(manager._FileManager__decrypt_content("some content"))
    print("Note: Accessed private method using name-mangled form")

elif test_case == "method_chaining":
    # Créer une instance de FileManager
    manager = FileManager()
    # Démontrer comment get_file_content appelle en interne les méthodes protégées et privées
    print("Calling get_file_content which internally uses protected and private methods:")
    print(manager.get_file_content("example.txt"))

elif test_case == "multiple_files":
    # Créer une instance de FileManager
    manager = FileManager()
    # Traiter plusieurs fichiers
    files = ["document.txt", "image.jpg", "data.csv"]
    
    for file in files:
        print(f"\
Processing {file}:")
        print(manager.read_file(file))
        print(manager.get_file_content(file))

elif test_case == "name_mangling":
    # Créer une instance de FileManager
    manager = FileManager()
    # Démontrer le "name mangling"
    print("Python's name mangling for private methods:")
    print("Attempting direct access would fail with AttributeError")
    print("Using mangled name:")
    print(manager._FileManager__decrypt_content("private data"))
    print("\
Name mangling is Python's mechanism to prevent accidental access")
    print("It renames __method to _ClassName__method internally")