Modificatori di accesso

Fa parte della sezione Programmazione orientata agli oggetti del percorso Python di Coddy. Lezione 29 di 64.

I modificatori di accesso controllano la visibilità degli attributi e dei metodi di una classe. Python usa convenzioni di denominazione anziché parole chiave per il controllo degli accessi.

Ecco un esempio di accesso pubblico (senza prefisso):

class Person:
    def __init__(self):
        self.name = "Coddy"      # Attributo pubblico
        
    def greet(self):             # Metodo pubblico
        return f"Hello, I'm {self.name}"

Accedi ai membri pubblici da qualsiasi punto:

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

Ecco un esempio di accesso protetto (underscore singolo):

class Employee:
    def __init__(self):
        self._salary = 50000     # Attributo protetto
    
    def _calculate_bonus(self):  # Metodo protetto
        return self._salary * 0.1

    def show_bonus(self):
        return self._calculate_bonus()  # Si può usare all'interno della classe

Accedi ai membri protetti (funziona, ma non è consigliato):

employee = Employee()
print(employee._salary)      # 50000 - funciona, pero no se recomienda
print(employee.show_bonus()) # 5000.0 - forma correcta

Ecco un esempio di accesso privato (doppio underscore):

class User:
    def __init__(self):
        self.__password = "secure123"   # Attributo privato
        
    def __encrypt(self, data):          # Metodo privato
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        # Membri privati accessibili all'interno della classe
        return input_password == self.__password

Usa correttamente i membri privati:

user = User()
print(user.verify("secure123"))  # True - utilizza un metodo pubblico
# print(user.__password)         # AttributeError - non è possibile accedervi direttamente

Output:

Coddy
Hello, I'm Coddy
50000
5000.0
True

Punto chiave: i modificatori di accesso di Python sono convenzioni di denominazione: nessun prefisso = pubblico (accessibile ovunque), un singolo trattino basso = protetto (uso interno), due trattini bassi = privato (solo nella classe). Aiutano a stabilire confini chiari e a prevenire l'uso improprio accidentale degli elementi interni della classe.

Sfida

Medio

In questa sfida implementerai una classe FileManager che dimostra i modificatori di accesso di Python (pubblico, protetto e privato), sperimentando al contempo i vantaggi dei test completi.

Modifica filemanager.py per implementare la classe FileManager seguendo i commenti TODO. Il file contiene istruzioni dettagliate per implementare:

Metodi pubblici per le operazioni sui file
Metodi protetti (con prefisso di un singolo trattino basso)
Metodi privati (con prefisso di due trattini bassi)
Interazioni tra metodi che dimostrano l'incapsulamento

Provalo tu

from file_manager import FileManager

# Gestore completo dei casi di test
test_case = input()

if test_case == "basic_test":
    # Crea un'istanza di FileManager
    manager = FileManager()
    # Chiama il metodo read_file
    print(manager.read_file("example.txt"))
    # Chiama il metodo get_file_content
    print(manager.get_file_content("example.txt"))

elif test_case == "protected_access":
    # Crea un'istanza di FileManager
    manager = FileManager()
    # Prova a chiamare il metodo protetto
    # I metodi protetti sono accessibili, ma sono destinati all'uso interno
    print(manager._check_permissions("example.txt"))
    print("Note: Protected methods are accessible but intended for internal use only")

elif test_case == "private_access":
    # Crea un'istanza di FileManager
    manager = FileManager()
    try:
        # Prova a chiamare direttamente il metodo privato
        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")
    
    # Accedi usando la forma con name mangling
    print(manager._FileManager__decrypt_content("some content"))
    print("Note: Accessed private method using name-mangled form")

elif test_case == "method_chaining":
    # Crea un'istanza di FileManager
    manager = FileManager()
    # Mostra come get_file_content chiama internamente sia i metodi protetti sia quelli privati
    print("Calling get_file_content which internally uses protected and private methods:")
    print(manager.get_file_content("example.txt"))

elif test_case == "multiple_files":
    # Crea un'istanza di FileManager
    manager = FileManager()
    # Elabora più file
    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":
    # Crea un'istanza di FileManager
    manager = FileManager()
    # Mostra il funzionamento del 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")