Modificadores de Acesso

Parte da seção Object Oriented Programming do Journey de Python da Coddy — lição 29 de 64.

Modificadores de acesso controlam a visibilidade de atributos e métodos de classe. O Python utiliza convenções de nomenclatura em vez de palavras-chave para o controle de acesso.

Aqui está um exemplo de acesso público (sem prefixo):

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}"

Acesse membros públicos de qualquer lugar:

person = Person()
print(person.name)           # Coddy
print(person.greet())        # Olá, eu sou o Coddy

Aqui está um exemplo de acesso protegido (sublinhado único):

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()  # OK para usar dentro da classe

Acesse membros protegidos (funciona, mas não é recomendado):

employee = Employee()
print(employee._salary)      # 50000 - funciona, mas é desencorajado
print(employee.show_bonus()) # 5000.0 - maneira correta

Aqui está um exemplo de acesso privado (sublinhado duplo):

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):
        # Membros privados acessíveis dentro da classe
        return input_password == self.__password

Use membros privados corretamente:

user = User()
print(user.verify("secure123"))  # True - usando método público
# print(user.__password)         # AttributeError - não é possível acessar diretamente

Saída:

Coddy
Hello, I'm Coddy
50000
5000.0
True

Ponto Chave: Os modificadores de acesso do Python são convenções de nomenclatura: sem prefixo = public (acessível em qualquer lugar), sublinhado único = protected (uso interno), sublinhado duplo = private (apenas para a classe). Eles ajudam a estabelecer limites claros e evitam o uso indevido acidental dos componentes internos da classe.

Desafio

Médio

Neste desafio, você implementará uma classe FileManager que demonstra os modificadores de acesso do Python (público, protegido e privado) enquanto experimenta os benefícios de testes abrangentes.

Edite filemanager.py para implementar a classe FileManager seguindo os comentários TODO. O arquivo contém instruções detalhadas para implementar:

Métodos públicos para operações de arquivo
Métodos protegidos (com prefixo de sublinhado único)
Métodos privados (com prefixo de sublinhado duplo)
Interações de métodos demonstrando encapsulamento

Folha de consulta

O Python usa convenções de nomenclatura para controle de acesso:

Acesso público (sem prefixo) - acessível em qualquer 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

Acesso protegido (sublinhado único) - uso interno, desencorajado por fora:

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, mas é desencorajado

Acesso privado (sublinhado duplo) - apenas para a classe:

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 método público
# print(user.__password)         # AttributeError - não é possível acessar diretamente

Experimente você mesmo

from file_manager import FileManager

# Manipulador abrangente de casos de teste
test_case = input()

if test_case == "basic_test":
    # Cria uma instância de FileManager
    manager = FileManager()
    # Chama o método read_file
    print(manager.read_file("example.txt"))
    # Chama o método get_file_content
    print(manager.get_file_content("example.txt"))

elif test_case == "protected_access":
    # Cria uma instância de FileManager
    manager = FileManager()
    # Tenta chamar o método protegido
    # Métodos protegidos são acessíveis, mas destinados ao 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":
    # Cria uma instância de FileManager
    manager = FileManager()
    try:
        # Tenta chamar o método privado diretamente
        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")
    
    # Acesso usando a forma de name-mangling
    print(manager._FileManager__decrypt_content("some content"))
    print("Note: Accessed private method using name-mangled form")

elif test_case == "method_chaining":
    # Cria uma instância de FileManager
    manager = FileManager()
    # Demonstra como get_file_content chama internamente métodos protegidos e 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":
    # Cria uma instância de FileManager
    manager = FileManager()
    # Processa múltiplos arquivos
    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":
    # Cria uma instância de FileManager
    manager = FileManager()
    # Demonstra 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")