Criação de algoritmo notas de alunos em phiyton

Você não disse qual é a dúvida

Exemplo de resolução para estudo do uso de classes e lista de objetos com Python

class Aluno:
    def __init__(self, matricula, nome, nota_prova1, nota_prova2):
        self.matricula = matricula
        self.nome = nome
        self.nota_prova1 = nota_prova1
        self.nota_prova2 = nota_prova2

    def calcular_media(self):
        return (self.nota_prova1 + self.nota_prova2) / 2

    def status_aprovacao(self):
        media = self.calcular_media()
        return "Aprovado" if media >= 6 else "Reprovado"

# Permita ao usuário entrar com os dados de pelo menos 3 alunos
alunos = []
num_alunos = int(input("Digite o número de alunos: "))

for i in range(num_alunos):
    matricula = input(f"Digite a matrícula do aluno {i + 1}: ")
    nome = input(f"Digite o nome do aluno {i + 1}: ")
    nota1 = float(input(f"Digite a nota da primeira prova do aluno {i + 1}: "))
    nota2 = float(input(f"Digite a nota da segunda prova do aluno {i + 1}: "))
    aluno = Aluno(matricula, nome, nota1, nota2)
    alunos.append(aluno)

# Encontre o aluno com a maior média geral
aluno_maior_media = max(alunos, key=lambda aluno: aluno.calcular_media())

# Encontre o aluno com a menor média geral
aluno_menor_media = min(alunos, key=lambda aluno: aluno.calcular_media())

# Para cada aluno, diga se ele foi aprovado ou reprovado
for aluno in alunos:
    print(f"\nAluno: {aluno.nome}")
    print(f"Média: {aluno.calcular_media()}")
    print(f"Status: {aluno.status_aprovacao()}")

# Exibir o aluno com a maior média
print(f"\nAluno com maior média geral: {aluno_maior_media.nome}")

# Exibir o aluno com a menor média
print(f"Aluno com menor média geral: {aluno_menor_media.nome}")

Claro, vou te ajudar a resolver esse problema! Vamos criar uma classe chamada `Aluno` que irá armazenar a matrícula, o nome, a nota da primeira e da segunda prova. Também criaremos métodos para calcular a média do aluno, acessar o nome e verificar se ele foi aprovado.

Além disso, o código permitirá que o usuário insira os dados de pelo menos 3 alunos, e em seguida, o programa encontrará o aluno com a maior média, o aluno com a menor média, e informará se cada aluno foi aprovado ou reprovado com base na média.

### Passo 1: Criando a classe `Aluno`

A classe `Aluno` terá os seguintes atributos:
- **Matrícula**: Um identificador único do aluno.
- **Nome**: Nome do aluno.
- **Nota1**: Nota da primeira prova.
- **Nota2**: Nota da segunda prova.

A classe terá os seguintes métodos:
- **Método `calcular_media()`**: Calcula a média das duas provas.
- **Método `aprovado()`**: Verifica se o aluno foi aprovado (nota >= 6).
- **Método `obter_nome()`**: Retorna o nome do aluno.

### Passo 2: Entradas de dados dos alunos

O programa permitirá que o usuário insira os dados de 3 alunos.

### Passo 3: Encontrar o aluno com a maior e menor média

Vamos usar uma lista para armazenar os objetos `Aluno` e depois calcular quem tem a maior e menor média.

### Passo 4: Verificar aprovação

Por fim, o código irá verificar se cada aluno foi aprovado ou reprovado.

### Código Completo:

```python
# Definição da classe Aluno
class Aluno:
    def __init__(self, matricula, nome, nota1, nota2):
        self.matricula = matricula  # Matrícula do aluno
        self.nome = nome  # Nome do aluno
        self.nota1 = nota1  # Nota da primeira prova
        self.nota2 = nota2  # Nota da segunda prova

    # Método para calcular a média do aluno
    def calcular_media(self):
        return (self.nota1 + self.nota2) / 2

    # Método para verificar se o aluno foi aprovado
    def aprovado(self):
        return self.calcular_media() >= 6

    # Método para obter o nome do aluno
    def obter_nome(self):
        return self.nome

# Função para cadastrar os alunos
def cadastrar_alunos():
    alunos = []
    for i in range(3):
        print(f"Cadastro do Aluno {i + 1}:")
        matricula = input("Digite a matrícula do aluno: ")
        nome = input("Digite o nome do aluno: ")
        nota1 = float(input("Digite a nota da primeira prova: "))
        nota2 = float(input("Digite a nota da segunda prova: "))
        aluno = Aluno(matricula, nome, nota1, nota2)
        alunos.append(aluno)
    return alunos

# Função para encontrar o aluno com a maior média
def aluno_maior_media(alunos):
    aluno_maior = alunos[0]
    for aluno in alunos:
        if aluno.calcular_media() > aluno_maior.calcular_media():
            aluno_maior = aluno
    return aluno_maior

# Função para encontrar o aluno com a menor média
def aluno_menor_media(alunos):
    aluno_menor = alunos[0]
    for aluno in alunos:
        if aluno.calcular_media() < aluno_menor.calcular_media():
            aluno_menor = aluno
    return aluno_menor

# Função principal
def main():
    # Cadastro dos alunos
    alunos = cadastrar_alunos()

    # Encontrando o aluno com a maior média
    aluno_maior = aluno_maior_media(alunos)
    print(f"\nAluno com maior média: {aluno_maior.obter_nome()} - Média: {aluno_maior.calcular_media()}")

    # Encontrando o aluno com a menor média
    aluno_menor = aluno_menor_media(alunos)
    print(f"Aluno com menor média: {aluno_menor.obter_nome()} - Média: {aluno_menor.calcular_media()}")

    # Verificando a aprovação de cada aluno
    for aluno in alunos:
        media = aluno.calcular_media()
        status = "Aprovado" if aluno.aprovado() else "Reprovado"
        print(f"\nAluno: {aluno.obter_nome()} - Média: {media} - Status: {status}")

# Execução do programa
if __name__ == "__main__":
    main()
```

### Explicação do Código:

1. **Classe `Aluno`**:
   - O método `__init__` é o construtor da classe, onde são definidos os atributos `matricula`, `nome`, `nota1` e `nota2`.
   - O método `calcular_media()` retorna a média das duas provas.
   - O método `aprovado()` verifica se o aluno foi aprovado, considerando a nota mínima de 6 para aprovação.
   - O método `obter_nome()` retorna o nome do aluno.

2. **Função `cadastrar_alunos()`**:
   - Esta função coleta os dados de 3 alunos e cria instâncias da classe `Aluno`, armazenando-os em uma lista.

3. **Funções `aluno_maior_media()` e `aluno_menor_media()`**:
   - Estas funções percorrem a lista de alunos e determinam o aluno com a maior e a menor média, respectivamente.

4. **Função `main()`**:
   - É a função principal que coordena o fluxo do programa.
   - Ela chama a função `cadastrar_alunos()` para obter os dados dos alunos.
   - Em seguida, ela chama as funções `aluno_maior_media()` e `aluno_menor_media()` para encontrar os alunos com maior e menor média.
   - Por fim, o programa verifica a aprovação de cada aluno e imprime o status.

### Exemplo de Execução:

**Entrada**:
```
Cadastro do Aluno 1:
Digite a matrícula do aluno: 12345
Digite o nome do aluno: João Silva
Digite a nota da primeira prova: 7.0
Digite a nota da segunda prova: 8.0

Cadastro do Aluno 2:
Digite a matrícula do aluno: 67890
Digite o nome do aluno: Maria Oliveira
Digite a nota da primeira prova: 5.5
Digite a nota da segunda prova: 6.0

Cadastro do Aluno 3:
Digite a matrícula do aluno: 11223
Digite o nome do aluno: José Santos
Digite a nota da primeira prova: 6.0
Digite a nota da segunda prova: 7.0
```

**Saída**:
```
Aluno com maior média: João Silva - Média: 7.5
Aluno com menor média: Maria Oliveira - Média: 5.75

Aluno: João Silva - Média: 7.5 - Status: Aprovado
Aluno: Maria Oliveira - Média: 5.75 - Status: Reprovado
Aluno: José Santos - Média: 6.5 - Status: Aprovado
```

### O que o código faz:
- O programa recebe as informações de 3 alunos.
- Calcula a média de cada aluno.
- Determina quem tem a maior e menor média.
- Informa se o aluno foi aprovado ou reprovado, com base na média.

Esse código segue o que foi solicitado e pode ser facilmente adaptado caso você precise de mais alunos ou mais funcionalidades. Se tiver mais dúvidas ou quiser personalizar o código, estou à disposição para ajudar!