Resolução de Atributos no Python

Antes de aprofundar no encapsulamento, é fundamental compreender como o Python resolve a busca por atributos. O dicionário interno de um objeto (__dict__) armazena apenas os atributos que são exclusivos daquela instância específica. Por outro lado, atributos e métodos compartilhados residem no dicionário da classe. Quando você acessa uma propriedade, o interpretador consulta primeiro o __dict__ da instância; caso não encontre, delega a busca para o __dict__ da classe.

O Conceito de Encapsulamento

O encapsulamento é um dos pilares da Programação Orientada a Objetos (POO). Ele consiste em agrupar dados e os métodos que operam sobre esses dados em uma única unidade (a classe), restringindo o acesso direto a alguns dos componentes do objeto. O objetivo principal é ocultar a complexidade interna, proteger o estado do objeto contra modificações inválidas e expor apenas uma interface pública clara e estável.

Benefícios Principais

• Organização Modular: Facilita a divisão do código em componentes independentes e reutilizáveis.
• Ocultação de Complexidade: Os usuários da classe não precisam saber como as operações são implementadas internamente, reduzindo o acoplamento.
• Proteção de Estado: Garante que os dados internos só sejam alterados através de regras de negócio predefinidas, aumentando a robustez da aplicação.

Ocultação de Atributos e Name Mangling

No Python, a convenção para indicar que um atributo ou método é de uso interno (protegido) é prefixá-lo com um sublinhado simples (_). No entanto, isso não impede o acesso externo. Para criar uma barreira mais forte, utiliza-se o prefixo de sublinhado duplo (__), que aciona um mecanismo chamado Name Mangling (deformação de nome).

O Name Mangling altera o nome do atributo internamente para _NomeDaClasse__nomeDoAtributo, dificultando o acesso acidental fora da classe.

class ContaBancaria:
    _taxa_admin = 5.0  # Atributo protegido (convenção)
    
    def __init__(self, titular, saldo_inicial):
        self.titular = titular
        self.__saldo = saldo_inicial  # Atributo privado (Name Mangling)
        
    def __validar_saque(self, valor):
        return valor <= self.__saldo

    def sacar(self, valor):
        if self.__validar_saque(valor):
            self.__saldo -= valor
            return True
        return False

conta = ContaBancaria("Maria", 1000.0)

# Acesso normal ao atributo público
print(conta.titular)  # Saída: Maria

# Acesso ao atributo protegido (possível, mas desencorajado)
print(conta._taxa_admin)  # Saída: 5.0

# Acesso direto ao atributo privado falha
# print(conta.__saldo)  # Levanta AttributeError

# Acesso via Name Mangling (não recomendado na prática)
print(conta._ContaBancaria__saldo)  # Saída: 1000.0

É crucial notar que a deformação do nome ocorre apenas no momento da definição da classe. Se você tentar adicionar dinamicamente um atributo com sublinhado duplo a uma instância já criada, o Name Mangling não será aplicado.

Exposição de Interfaces Públicas

A verdadeira essência do encapsulamento não é apenas esconder dados, mas fornecer métodos públicos (interfaces) que permitam a interação segura com o estado oculto. Isso isola as mudanças internas: se a lógica de cálculo ou a estrutura de dados mudar, a interface pública pode permanecer inalterada, não quebrando o código dos clientes da classe.

class Motor:
    def __init__(self):
        self.__temperatura = 20
        self.__ligado = False

    def __aquecer(self):
        self.__temperatura += 15

    def __resfriar(self):
        self.__temperatura -= 5

    def iniciar(self):
        if not self.__ligado:
            self.__ligado = True
            self.__aquecer()
            return "Motor iniciado com sucesso."
        return "O motor já está ligado."

    def desligar(self):
        if self.__ligado:
            self.__ligado = False
            self.__resfriar()
            return "Motor desligado."
        return "O motor já está desligado."

    def get_status(self):
        estado = "Ligado" if self.__ligado else "Desligado"
        return f"Status: {estado} | Temperatura: {self.__temperatura}°C"

meu_motor = Motor()
print(meu_motor.iniciar())
print(meu_motor.get_status())
print(meu_motor.desligar())
print(meu_motor.get_status())

Gerenciamento Avançado com @property

O decorador @property é uma ferramenta poderosa no Python que permite transformar métodos em atributos de leitura. Isso é extremamente útil quando você precisa executar lógica computacional ao acessar um valor, mas deseja manter a sintaxe de acesso simples para o usuário da classe.

class Produto:
    def __init__(self, nome, preco_base, categoria):
        self.nome = nome
        self.categoria = categoria
        self.__preco_base = preco_base

    @property
    def preco_final(self):
        # Lógica de cálculo de impostos baseada na categoria
        if self.categoria == "eletronicos":
            return self.__preco_base * 1.20
        elif self.categoria == "alimentos":
            return self.__preco_base * 1.05
        return self.__preco_base

item = Produto("Notebook", 3000.0, "eletronicos")
# Acessado como atributo, embora execute um método internamente
print(f"Preço com impostos: R$ {item.preco_final:.2f}")

Getters, Setters e Deleters

Além de criar atributos de leitura, o @property permite definir comportamentos para atribuição (setter) e exclusão (deleter), garantindo validações rigorosas.

class Funcionario:
    def __init__(self, nome_completo, salario):
        self.nome_completo = nome_completo
        self.__salario = salario

    @property
    def salario(self):
        return self.__salario

    @salario.setter
    def salario(self, novo_valor):
        if novo_valor < 0:
            raise ValueError("O salário não pode ser negativo.")
        if novo_valor < self.__salario:
            raise ValueError("Reduções salariais não são permitidas por esta interface.")
        self.__salario = novo_valor

    @salario.deleter
    def salario(self):
        print("Registro salarial removido por motivos de auditoria.")
        self.__salario = 0.0

colaborador = Funcionario("João Silva", 5000.0)
print(colaborador.salario)  # Saída: 5000.0

colaborador.salario = 5500.0  # Aciona o setter
print(colaborador.salario)  # Saída: 5500.0

# colaborador.salario = 4000.0  # Levanta ValueError

del colaborador.salario  # Aciona o deleter
print(colaborador.salario)  # Saída: 0.0

Alternativamente, a função embutida property() pode ser usada para mapear métodos get, set e del explicitamente, oferecendo a mesma funcionalidade dos decoradores, o que pode ser útil em cenários de metaprogramação ou quando se trabalha com classes geradas dinamicamente.

class Configuracao:
    def __init__(self):
        self.__nivel_log = "INFO"

    def _obter_nivel(self):
        return self.__nivel_log

    def _definir_nivel(self, valor):
        niveis_validos = ["DEBUG", "INFO", "WARNING", "ERROR"]
        if valor not in niveis_validos:
            raise ValueError(f"Nível inválido. Escolha entre: {niveis_validos}")
        self.__nivel_log = valor

    def _apagar_nivel(self):
        self.__nivel_log = "INFO"  # Reseta para o padrão

    nivel_log = property(fget=_obter_nivel, fset=_definir_nivel, fdel=_apagar_nivel)

cfg = Configuracao()
cfg.nivel_log = "DEBUG"
print(cfg.nivel_log)