[Bug] Inconsistência do enunciado que leva muitos alunos a se equivocar

Olá pessoal! Gostaria de levantar um ponto sobre a abordagem sugerida para o método ativar_conta da classe ContaBancaria.

No exemplo proposto:

@classmethod
def ativar_conta(cls, conta):
    conta._ativo = True

Essa abordagem me parece desnecessária e até contraintuitiva em relação ao uso adequado da Orientação a Objetos em Python. Isso porque:

O método não precisa ser de classe (@classmethod), já que ele age sobre um objeto específico (conta) e modifica seus atributos diretamente.

Estamos passando o objeto como parâmetro, o que foge do padrão de usar self para modificar o estado interno da instância que chamou o método.

O nome ativar_conta sugere que queremos ativar a conta – mas o código apenas força _ativo = True, sem considerar o estado anterior ou permitir alternância.

Uma alternativa mais “pythônica” e prática seria implementar como um método de instância:

def ativar_conta(self):
    self._ativo = not self._ativo

Dessa forma:

O método pode ser chamado diretamente pela instância (conta.ativar_conta()), o que é mais natural.

A lógica usa not self._ativo, o que permite alternar entre ativo e inativo, tornando o método mais flexível.

É mais alinhado à convenção orientada a objetos em Python, que prioriza métodos de instância para manipular atributos internos

Olá Murilo! Como vai?

Você está correto ao apontar que o uso de @classmethod para o método ativar_conta pode não ser a melhor escolha, já que ele atua sobre uma instância específica. Métodos de classe são mais adequados quando precisamos de um comportamento que envolva a classe como um todo, e não uma instância específica.

Ao passar o objeto como parâmetro, realmente estamos fugindo do padrão usual de usar self para manipular atributos internos. O uso de self é mais intuitivo e mantém a consistência com a prática comum em Python.

Sua sugestão de usar self._ativo = not self._ativo é muito interessante, pois adiciona flexibilidade ao método, permitindo alternar o estado da conta entre ativo e inativo. Isso torna o método mais dinâmico e útil em diferentes cenários.

Aqui está como ficaria a implementação seguindo sua sugestão:

class ContaBancaria:
    def __init__(self, titular, saldo):
        self.titular = titular
        self.saldo = saldo
        self._ativo = False

    def ativar_conta(self):
        self._ativo = not self._ativo

    def __str__(self):
        return f"Titular: {self.titular}, Saldo: {self.saldo}, Ativo: {self._ativo}"

# Exemplo de uso
conta = ContaBancaria("João", 1000)
print(conta)  # Antes de ativar
conta.ativar_conta()
print(conta)  # Depois de ativar

Essa abordagem é mais alinhada com as práticas recomendadas em Python e oferece uma maneira mais intuitiva de manipular o estado da conta. Espero que essa explicação tenha sido útil para você.

Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!