Modificadores de acceso

Parte de la sección Object Oriented Programming del Journey de Python de Coddy — lección 29 de 64.

Los modificadores de acceso controlan la visibilidad de los atributos y métodos de clase. Python utiliza convenciones de nomenclatura en lugar de palabras clave para el control de acceso.

Aquí hay un ejemplo de acceso público (sin prefijo):

class Person:
    def __init__(self):
        self.name = "Coddy"      # Atributo público
        
    def greet(self):             # Método público
        return f"Hello, I'm {self.name}"

Accede a los miembros públicos desde cualquier lugar:

person = Person()
print(person.name)           # Coddy
print(person.greet())        # Hola, soy Coddy

Aquí hay un ejemplo de acceso protegido (guion bajo simple):

class Employee:
    def __init__(self):
        self._salary = 50000     # Atributo protegido
    
    def _calculate_bonus(self):  # Método protegido
        return self._salary * 0.1

    def show_bonus(self):
        return self._calculate_bonus()  # Está bien usarlo dentro de la clase

Acceder a miembros protegidos (funciona pero no se recomienda):

employee = Employee()
print(employee._salary)      # 50000 - funciona pero se desaconseja
print(employee.show_bonus()) # 5000.0 - forma adecuada

Aquí hay un ejemplo de acceso privado (doble guion bajo):

class User:
    def __init__(self):
        self.__password = "secure123"   # Atributo privado
        
    def __encrypt(self, data):          # Método privado
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        # Miembros privados accesibles dentro de la clase
        return input_password == self.__password

Usa los miembros privados correctamente:

user = User()
print(user.verify("secure123"))  # True - usando el método público
# print(user.__password)         # AttributeError - no se puede acceder directamente

Salida:

Coddy
Hello, I'm Coddy
50000
5000.0
True

Punto clave: Los modificadores de acceso de Python son convenciones de nomenclatura: sin prefijo = público (accesible desde cualquier lugar), guion bajo simple = protegido (uso interno), doble guion bajo = privado (solo clase). Estos ayudan a establecer límites claros y a prevenir el uso indebido accidental de los componentes internos de la clase.

Desafío

Intermedio

En este desafío, implementarás una clase FileManager que demuestra los modificadores de acceso de Python (públicos, protegidos y privados) mientras experimentas los beneficios de las pruebas exhaustivas.

Edita filemanager.py para implementar la clase FileManager siguiendo los comentarios TODO. El archivo contiene instrucciones detalladas para implementar:

Métodos públicos para operaciones de archivos
Métodos protegidos (con prefijo de guion bajo simple)
Métodos privados (con prefijo de guion bajo doble)
Interacciones de métodos que demuestran el encapsulamiento

Hoja de referencia

Python utiliza convenciones de nomenclatura para el control de acceso:

Acceso público (sin prefijo) - accesible desde cualquier lugar:

class Person:
    def __init__(self):
        self.name = "Coddy"      # Atributo público
        
    def greet(self):             # Método público
        return f"Hello, I'm {self.name}"

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

Acceso protegido (guion bajo simple) - uso interno, desaconsejado desde el exterior:

class Employee:
    def __init__(self):
        self._salary = 50000     # Atributo protegido
    
    def _calculate_bonus(self):  # Método protegido
        return self._salary * 0.1

employee = Employee()
print(employee._salary)      # Funciona pero se desaconseja

Acceso privado (doble guion bajo) - solo para la clase:

class User:
    def __init__(self):
        self.__password = "secure123"   # Atributo privado
        
    def __encrypt(self, data):          # Método privado
        return f"Encrypted: {data}"
        
    def verify(self, input_password):
        return input_password == self.__password

user = User()
print(user.verify("secure123"))  # True - usando el método público
# print(user.__password)         # AttributeError - no se puede acceder directamente

Pruébalo tú mismo

from file_manager import FileManager

# Controlador de casos de prueba exhaustivo
test_case = input()

if test_case == "basic_test":
    # Crear una instancia de FileManager
    manager = FileManager()
    # Llamar al método read_file
    print(manager.read_file("example.txt"))
    # Llamar al método get_file_content
    print(manager.get_file_content("example.txt"))

elif test_case == "protected_access":
    # Crear una instancia de FileManager
    manager = FileManager()
    # Intentar llamar al método protegido
    # Los métodos protegidos son accesibles pero están destinados a 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":
    # Crear una instancia de FileManager
    manager = FileManager()
    try:
        # Intentar llamar al método privado directamente
        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")
    
    # Acceso utilizando la forma de nombre alterado (name-mangling)
    print(manager._FileManager__decrypt_content("some content"))
    print("Note: Accessed private method using name-mangled form")

elif test_case == "method_chaining":
    # Crear una instancia de FileManager
    manager = FileManager()
    # Demostrar cómo get_file_content llama internamente a métodos protegidos y privados
    print("Calling get_file_content which internally uses protected and private methods:")
    print(manager.get_file_content("example.txt"))

elif test_case == "multiple_files":
    # Crear una instancia de FileManager
    manager = FileManager()
    # Procesar múltiples archivos
    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":
    # Crear una instancia de FileManager
    manager = FileManager()
    # Demostrar el name mangling (alteración de nombres)
    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")