Solucionado (ver solução)

Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

Solucionado
(ver solução)
3
respostas

Resolução de Atividades - 05 Organizando notas de um concurso de redação

Sim, eu sei. Eu compliquei algo que era simples. Só percebi quando vi a solução no gabarito, mas como eu já tinha feito tudo, decidi enviar a minah resolução mesmo assim. Na minha visão, como foi seguido do curso de Orientação a Objetos, achei que era para ser feito em POO. Tadinho de mim... (Carinha de palhaço).


PARTE 1


models/aluno.py


class Aluno:

    """Representa um aluno com nome e lista de notas"""

    lista_alunos = []

    def __init__ (self, nome: str, ID = None):
        
        self.nome = nome
        self.id = ID
        self.notas = []
        Aluno.lista_alunos.append (self)

    @classmethod

    def adicionar_aluno (cls):

        """Adiciona um aluno à lista de alunos"""

        nome_aluno = input ("Digite o nome completo do aluno: ")
        id_aluno = input ("Digite o ID do aluno(a): ")

        for aluno in cls.lista_alunos:

            if aluno.id == id_aluno:

                print (f"\nO ID {id_aluno} já está cadastrado para o aluno(a) {aluno.nome}. Tente novamente com outro ID.")
                return
            
        aluno = cls (nome_aluno, id_aluno)
        print (f"\nO(A) aluno(a) {aluno.nome} foi adicionado(a) com sucesso!")

    @classmethod

    def buscar_aluno_por_id (cls, ID):

        """ 
        Busca um aluno na lista com base na Chave Primária - ID
        
        Parâmetros:
        - ID: int
        """

        for aluno in cls.lista_alunos:

            if ID == aluno.id:

                return aluno

            else:

                return None

    @classmethod

    def remover_aluno (cls):

        """ Remove um aluno da lista de alunos """

        id = input ("Digite o ID do aluno que deseja remover: ")

        aluno_remover = cls.buscar_aluno_por_id(id)

        if aluno_remover == None:
            
            print("Aluno não encontrado.")

        else:

            confirmacao = input (f"Deseja realmente deletar o aluno {aluno_remover.nome}? (S / qualquer outra tecla para cancelar)")

            if confirmacao == "S":

                cls.lista_alunos.remove (aluno_remover)

            else:

                print ("Voltando ao Menu Principal")

    @classmethod

    def mostrar_lista_alunos (cls):

        """ Mostra a lista de alunos cadastrados no sistema """

        if len (cls.lista_alunos) == 0:

            print ("Não há alunos disponíveis na lista. Ela está vazia!")

        else:

            print (f"{"Alunos".ljust(25)} | {"ID".ljust(25)} | {"Média".ljust(25)}")

            for item in cls.lista_alunos:

                print (f"{item.nome.ljust(25)} | {str(item.id).ljust(25)} | {str((sum(item.notas) / len(item.notas)) if item.notas else 0).ljust(25)}")

    def adicionar_nota (self, nota = 0):

        if nota <= 10 and nota >= 0:

            self.notas.append (nota)

        else:

            print ("Nota inválida. Tente novamente!")

    def remover_nota (self, nota = 0):

        if nota in self.notas:

            self.notas.remove (nota)

        else:

            print ("Nota não encontrada. Tente novamente!")

[NOTE!]
Continua porque estourou o limite de caracteres =(

3 respostas
solução!

Olá, Victor! Como vai?

Parabéns pela dedicação na sua solução!

Vi que você explorou a orientação a objetos para estruturar o gerenciamento de alunos em Python, utilizou muito bem a classe Aluno com métodos de classe e instância para organizar as operações e ainda compreendeu a importância da lista compartilhada para manter os registros centralizados.

Uma dica interessante para o futuro é separar a lógica de persistência (armazenamento dos alunos) da lógica de negócio. Por exemplo, você poderia ter uma classe RepositorioAlunos responsável apenas por salvar, buscar e remover alunos, enquanto a classe Aluno ficaria focada em representar os dados e comportamentos individuais. Assim:

class RepositorioAlunos:
    lista_alunos = []

    @classmethod
    def adicionar(cls, aluno):
        cls.lista_alunos.append(aluno)

    @classmethod
    def buscar_por_id(cls, ID):
        for aluno in cls.lista_alunos:
            if aluno.id == ID:
                return aluno
        return None

Isso faz com que o código fique mais modular e fácil de manter, além de permitir evoluções futuras como salvar os dados em arquivos ou banco de dados.

Se quiser aprofundar ainda mais, algumas boas práticas são:

  • Validação de entradas: garantir que IDs não sejam duplicados e que notas estejam sempre entre 0 e 10.
  • Organização em pacotes: separar modelos, lógica de negócio e interface para deixar o projeto mais escalável.
  • Corrigir o método buscar_aluno_por_id: atualmente ele retorna None logo na primeira iteração se o ID não bater. O ideal é só retornar None depois de percorrer toda a lista.

Alguns materiais podem estar em inglês, mas é possível compreendê-los usando o recurso de tradução de páginas do próprio navegador.

Ah, uma pergunta: você acha que separar a lógica em classes diferentes (uma para representar alunos e outra para gerenciar a lista) deixaria o sistema mais claro e modular ou prefere manter tudo centralizado na classe Aluno para simplificar?

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

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

Oii senhor Daniel, tudo bem? Agradeço pelas recomendações e ajustes. Acabei de corrigir o método buscar_aluno_por_id. Agora ele só retorna o None se o laço "for" terminar.

Respondendo a sua pergunta, acredito que sim, deixaria o sistema mais limpo. Porque eu mesmo, quando estava desenvolvendo o programa, me perdia muito com a quantidade de métodos da classe Aluno. Separar essas funções em uma classe específica, que seria o registro dos alunos, é mais recomendável. Então realmente separar as duas lógicas deixaria o código mais organlizado.

Agradeço o carinho. Vou realizar mais exercícios hoje, tentarei não criar arquivos grandes de novo ksksksk, então me aguarde.

Olá, Victor! Tudo bem?

Mandou muito bem na correção do método buscar_aluno_por_id.

Essa mudança de só retornar None após o término do laço deixa o código mais consistente e evita resultados inesperados. Além disso, sua percepção sobre separar responsabilidades em classes específicas é excelente: organizar a lógica de alunos em uma classe dedicada realmente torna o sistema mais limpo e fácil de manter.

Gostei também da sua sinceridade sobre se perder com muitos métodos dentro da mesma classe, isso acontece no início. E perceber essa necessidade de organização já mostra maturidade no desenvolvimento.

Continue praticando e não se preocupe com arquivos grandes, cada exercício é uma oportunidade de lapidar ainda mais sua forma de estruturar código.

Forte abraço e bons estudos!