Crie uma classe representando os alunos de um curso. A classe deve conter os atributos matrícula do aluno, nome, nota da primeira e da segunda prova. Crie métodos para acessar o nome e a média do aluno.
a) Permita ao usuário entrar com os dados de 3 alunos;
b) encontre o aluno com maior média geral.
c) encontre o aluno com menor média geral.
d) para cada aluno diga se ele foi aprovado ou reprovado, considerando nota 6 para aprovação.
isso se encaixa melhor em tarefas.
Anuncia lá que alguém pode fazer por vc por um preço .
Qualquer coisa também pode entrar em contato cmg e te ensino a fazer em uma aula.
Entra em contato comigo que eu resolvo pra ti.
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"
# a) Permita ao usuário entrar com os dados de 3 alunos
alunos = []
for i in range(3):
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)
# b) Encontre o aluno com maior média geral
aluno_maior_media = max(alunos, key=lambda aluno: aluno.calcular_media())
# c) Encontre o aluno com menor média geral
aluno_menor_media = min(alunos, key=lambda aluno: aluno.calcular_media())
# d) 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 maior média
print(f"\nAluno com maior média geral: {aluno_maior_media.nome}")
# Exibir o aluno com menor média
print(f"Aluno com menor média geral: {aluno_menor_media.nome}")
|
class Aluno:
def __init__(self, matricula, nome, nota1, nota2):
self.matricula = matricula
self.nome = nome
self.nota1 = nota1
self.nota2 = nota2
def get_nome(self):
return self.nome
def media(self):
return (self.nota1 + self.nota2) / 2
def status(self):
return "Aprovado" if self.media() >= 6 else "Reprovado"
# a) Permitir ao usuário entrar com os dados de 3 alunos
alunos = []
for i in range(3):
print(f"Digite os dados do aluno {i+1}:")
matricula = input("Matrícula: ")
nome = input("Nome: ")
nota1 = float(input("Nota da primeira prova: "))
nota2 = float(input("Nota da segunda prova: "))
aluno = Aluno(matricula, nome, nota1, nota2)
alunos.append(aluno)
# b) Encontrar o aluno com maior média geral
aluno_maior_media = max(alunos, key=lambda aluno: aluno.media())
print(f"Aluno com maior média: {aluno_maior_media.get_nome()}, Média: {aluno_maior_media.media()}")
# c) Encontrar o aluno com menor média geral
aluno_menor_media = min(alunos, key=lambda aluno: aluno.media())
print(f"Aluno com menor média: {aluno_menor_media.get_nome()}, Média: {aluno_menor_media.media()}")
# d) Para cada aluno, dizer se ele foi aprovado ou reprovado
for aluno in alunos:
print(f"{aluno.get_nome()} - Média: {aluno.media()} - {aluno.status()}")
|
class Aluno:
def __init__(self, matricula, nome, nota1, nota2):
self.matricula = matricula
self.nome = nome
self.nota1 = nota1
self.nota2 = nota2
def calcular_media(self):
return (self.nota1 + self.nota2) / 2
def verificar_aprovacao(self):
media = self.calcular_media()
if media >= 6:
return "Aprovado"
else:
return "Reprovado"
# Função para encontrar aluno com maior média geral
def encontrar_maior_media(alunos):
maior_media = -1
aluno_maior_media = None
for aluno in alunos:
media = aluno.calcular_media()
if media > maior_media:
maior_media = media
aluno_maior_media = aluno
return aluno_maior_media
# Função para encontrar aluno com menor média geral
def encontrar_menor_media(alunos):
menor_media = float('inf')
aluno_menor_media = None
for aluno in alunos:
media = aluno.calcular_media()
if media < menor_media:
menor_media = media
aluno_menor_media = aluno
return aluno_menor_media
# Entrada de dados
alunos = []
for i in range(3):
print(f"Informações do aluno {i+1}:")
matricula = input("Matrícula: ")
nome = input("Nome: ")
nota1 = float(input("Nota da primeira prova: "))
nota2 = float(input("Nota da segunda prova: "))
alunos.append(Aluno(matricula, nome, nota1, nota2))
# Encontrar aluno com maior média
aluno_maior_media = encontrar_maior_media(alunos)
print(f"\nAluno com maior média geral:")
print(f"Nome: {aluno_maior_media.nome}")
print(f"Média: {aluno_maior_media.calcular_media()}")
print(f"Situação: {aluno_maior_media.verificar_aprovacao()}")
# Encontrar aluno com menor média
aluno_menor_media = encontrar_menor_media(alunos)
print(f"\nAluno com menor média geral:")
print(f"Nome: {aluno_menor_media.nome}")
print(f"Média: {aluno_menor_media.calcular_media()}")
print(f"Situação: {aluno_menor_media.verificar_aprovacao()}")
Aqui está uma solução em Python para o exercício proposto, onde criamos uma classe **Aluno** que possui os atributos de matrícula, nome, nota da primeira e da segunda prova. Implementamos métodos para acessar o nome e calcular a média, além de permitir que o usuário insira os dados de 3 alunos, encontrar os alunos com maior e menor média e informar se cada aluno foi aprovado ou reprovado.
### Código:
```python
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 acessar o nome do aluno
def obter_nome(self):
return self.nome
# Método para calcular e retornar 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
# Função para receber os dados dos alunos
def cadastrar_alunos():
alunos = []
for i in range(3):
print(f"Cadastro do Aluno {i + 1}:")
matricula = input("Digite a matrícula: ")
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 para rodar o programa
def main():
# Cadastro de 3 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 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}")
if __name__ == "__main__":
main()
```
### Explicação do Código:
1. **Classe Aluno**:
- **Atributos**: `matricula`, `nome`, `nota1`, `nota2`.
- **Métodos**:
- `obter_nome()`: Retorna o nome do aluno.
- `calcular_media()`: Calcula e retorna a média das notas (média das duas provas).
- `aprovado()`: Retorna **True** se a média for maior ou igual a 6, indicando que o aluno foi aprovado.
2. **Funções**:
- `cadastrar_alunos()`: Coleta os dados de 3 alunos via `input()` e os armazena em uma lista de objetos `Aluno`.
- `aluno_maior_media()`: Encontra o aluno com a maior média.
- `aluno_menor_media()`: Encontra o aluno com a menor média.
3. **Função Principal (`main()`)**:
- Chama a função de cadastro, encontra o aluno com a maior e menor média e verifica a aprovação de cada aluno, exibindo os resultados no console.
### Exemplo de Execução:
**Entrada**:
```
Cadastro do Aluno 1:
Digite a matrícula: 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: 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: 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
```
### Observações:
- O programa usa **entrada de dados** para registrar 3 alunos, calculando suas médias e avaliando sua aprovação com base na nota mínima de 6.
- A função `aprovado()` simplifica a verificação da aprovação do aluno.
Aulas particulares
