Como Determinar a Nota com Base nas Notas Usando if-elif-else em Python

PythonBeginner
Pratique Agora

Introdução

Este tutorial irá guiá-lo através do processo de implementação de um sistema de avaliação usando as instruções if-elif-else do Python. Você aprenderá como determinar a nota de um aluno com base em suas notas, uma tarefa comum em ambientes educacionais. Ao final deste tutorial, você terá criado um programa de avaliação funcional que pode ser aplicado a cenários do mundo real. Essa abordagem prática fortalecerá sua compreensão das instruções condicionais em Python, que são blocos de construção fundamentais para uma lógica de programação mais complexa.

Compreendendo as Instruções Condicionais em Python

Antes de criarmos nosso sistema de avaliação, vamos entender as instruções condicionais básicas em Python. As instruções condicionais permitem que seu programa tome decisões com base em condições específicas.

Criando Seu Primeiro Arquivo Python

Vamos começar criando um novo arquivo Python:

  1. No WebIDE, clique no menu "File" (Arquivo) no canto superior esquerdo
  2. Selecione "New File" (Novo Arquivo)
  3. Salve o arquivo como conditional_demo.py no diretório /home/labex/project

Instrução If-Else Básica

No seu arquivo conditional_demo.py, escreva o seguinte código:

## Basic if-else example
score = 75

if score >= 70:
    print("You passed the test!")
else:
    print("You need to study more.")

## Try changing the score to see different results

Este programa simples verifica se a variável score é 70 ou superior. Se for, ele imprime "You passed the test!". Caso contrário, ele imprime "You need to study more."

Testando Seu Código

Para executar seu código, abra um terminal no WebIDE e execute:

python3 /home/labex/project/conditional_demo.py

Você deve ver a saída:

You passed the test!

Adicionando Mais Condições com If-Elif-Else

Vamos expandir nosso exemplo para lidar com mais condições usando a estrutura if-elif-else:

## If-elif-else example
score = 85

if score >= 90:
    print("Excellent!")
elif score >= 80:
    print("Very good!")
elif score >= 70:
    print("Good!")
elif score >= 60:
    print("Satisfactory")
else:
    print("Needs improvement")

## Try different values for score to see different results

Salve o arquivo e execute-o novamente:

python3 /home/labex/project/conditional_demo.py

Saída:

You passed the test!
Very good!

A estrutura if-elif-else avalia as condições de cima para baixo. Uma vez que uma condição é verdadeira, seu bloco de código correspondente é executado, e o restante das condições é ignorado.

Compreender este fluxo é crucial para construir nosso sistema de avaliação no próximo passo.

Criando um Sistema de Avaliação Básico

Agora que entendemos as instruções condicionais, vamos construir um sistema de avaliação simples. Criaremos uma função que converte notas numéricas em notas por letras.

Criando o Arquivo do Sistema de Avaliação

  1. No WebIDE, crie um novo arquivo chamado grading_system.py
  2. Salve-o no diretório /home/labex/project

Implementando a Função de Avaliação Básica

No seu arquivo grading_system.py, escreva o seguinte código:

def get_grade(marks):
    """
    Convert numerical marks to letter grades.

    A: 90-100
    B: 80-89
    C: 70-79
    D: 60-69
    F: 0-59
    """
    if marks >= 90:
        return 'A'
    elif marks >= 80:
        return 'B'
    elif marks >= 70:
        return 'C'
    elif marks >= 60:
        return 'D'
    else:
        return 'F'

## Test the function with a few examples
test_marks = [95, 82, 75, 65, 45]

for mark in test_marks:
    grade = get_grade(mark)
    print(f"Marks: {mark} - Grade: {grade}")

Este código cria uma função get_grade() que recebe as notas de um aluno como entrada e retorna a nota por letra correspondente com base em limites de avaliação comuns.

Executando Nosso Sistema de Avaliação

Vamos testar nosso sistema de avaliação executando o código:

python3 /home/labex/project/grading_system.py

Você deve ver uma saída semelhante a:

Marks: 95 - Grade: A
Marks: 82 - Grade: B
Marks: 75 - Grade: C
Marks: 65 - Grade: D
Marks: 45 - Grade: F

Compreendendo o Código

Vamos detalhar como isso funciona:

  1. Definimos uma função chamada get_grade() que recebe um parâmetro: marks (notas)
  2. Dentro da função, usamos instruções if-elif-else para verificar as notas em relação a diferentes limites de notas
  3. Criamos uma lista de notas de teste para demonstrar como a função funciona com diferentes valores
  4. Usamos um loop for para iterar por cada nota, obter sua nota e imprimir o resultado

Este sistema de avaliação básico funciona bem para casos padrão, mas e quanto aos casos extremos (edge cases)? No próximo passo, melhoraremos nosso sistema para lidar com eles.

Lidando com Casos Extremos em Nosso Sistema de Avaliação

Nosso sistema de avaliação básico funciona, mas não leva em consideração casos extremos (edge cases), como:

  1. Entradas inválidas (notas menores que 0 ou maiores que 100)
  2. Entradas não numéricas

Vamos melhorar nosso sistema de avaliação para lidar com esses cenários.

Atualize o Sistema de Avaliação

Crie um novo arquivo chamado improved_grading.py no diretório /home/labex/project com o seguinte código:

def get_grade(marks):
    """
    Convert numerical marks to letter grades with input validation.

    A: 90-100
    B: 80-89
    C: 70-79
    D: 60-69
    F: 0-59

    Returns "Invalid marks" for inputs outside the range of 0-100
    """
    try:
        ## Convert to float in case input is a string number
        marks = float(marks)

        ## Check if marks are in valid range
        if marks < 0 or marks > 100:
            return "Invalid marks: must be between 0 and 100"
        elif marks >= 90:
            return 'A'
        elif marks >= 80:
            return 'B'
        elif marks >= 70:
            return 'C'
        elif marks >= 60:
            return 'D'
        else:
            return 'F'
    except ValueError:
        return "Invalid marks: not a number"

## Test the function with valid and invalid inputs
test_inputs = [95, 82, 75, 65, 45, -5, 105, "abc", "75"]

for value in test_inputs:
    grade = get_grade(value)
    print(f"Input: {value} - Result: {grade}")

Execute o Sistema de Avaliação Melhorado

Execute o sistema de avaliação aprimorado:

python3 /home/labex/project/improved_grading.py

A saída deve ser semelhante a:

Input: 95 - Result: A
Input: 82 - Result: B
Input: 75 - Result: C
Input: 65 - Result: D
Input: 45 - Result: F
Input: -5 - Result: Invalid marks: must be between 0 and 100
Input: 105 - Result: Invalid marks: must be between 0 and 100
Input: abc - Result: Invalid marks: not a number
Input: 75 - Result: C

Melhorias Explicadas

Vamos examinar as melhorias que fizemos:

  1. Conversão do Tipo de Entrada: Usamos float() para converter a entrada em um número, permitindo que nossa função aceite entradas de string como "75"

  2. Verificação de Intervalo Válido: Adicionamos uma condição para verificar se as notas estão dentro do intervalo válido de 0-100

  3. Tratamento de Erros: Envolvemos nosso código em um bloco try-except para capturar exceções ValueError que ocorrem quando entradas não numéricas são fornecidas

  4. Mensagens de Erro Detalhadas: Retornamos mensagens de erro específicas para informar ao usuário o que deu errado, em vez de apenas retornar um código de erro

Essas melhorias tornam nosso sistema de avaliação mais robusto, lidando com vários casos extremos de forma adequada. O programa agora fornece feedback útil quando entradas inválidas são encontradas, em vez de travar ou produzir resultados incorretos.

Aprimorando o Sistema de Avaliação com Mensagens de Feedback

Vamos aprimorar ainda mais nosso sistema de avaliação adicionando mensagens de feedback personalizadas para cada nota. Isso torna o sistema mais informativo e amigável para o usuário.

Criando o Sistema de Avaliação Aprimorado

Crie um novo arquivo chamado enhanced_grading.py no diretório /home/labex/project:

def get_grade_with_feedback(marks):
    """
    Convert numerical marks to letter grades with personalized feedback.

    Returns a tuple containing the grade and a feedback message.
    """
    try:
        marks = float(marks)

        if marks < 0 or marks > 100:
            return (None, "Invalid marks: must be between 0 and 100")
        elif marks >= 90:
            return ('A', "Excellent! Outstanding performance.")
        elif marks >= 80:
            return ('B', "Very good! Above average performance.")
        elif marks >= 70:
            return ('C', "Good work! Average performance.")
        elif marks >= 60:
            return ('D', "Satisfactory. Below average but passing.")
        else:
            return ('F', "Needs improvement. Please study more.")
    except ValueError:
        return (None, "Invalid marks: not a number")

def format_report(student_name, marks, subject):
    """
    Generate a formatted report for a student.
    """
    grade, feedback = get_grade_with_feedback(marks)

    if grade is None:
        return f"Report for {student_name}: {feedback}"

    return f"""
Report Card
-----------
Student: {student_name}
Subject: {subject}
Marks: {marks}
Grade: {grade}
Feedback: {feedback}
"""

## Test the enhanced system with a few examples
students = [
    {"name": "Alice", "marks": 92, "subject": "Mathematics"},
    {"name": "Bob", "marks": 78, "subject": "Science"},
    {"name": "Charlie", "marks": 45, "subject": "History"},
    {"name": "David", "marks": "abc", "subject": "English"}
]

for student in students:
    report = format_report(student["name"], student["marks"], student["subject"])
    print(report)

Executando o Sistema de Avaliação Aprimorado

Execute o sistema de avaliação aprimorado:

python3 /home/labex/project/enhanced_grading.py

Você deve ver uma saída semelhante a:

Report Card
-----------
Student: Alice
Subject: Mathematics
Marks: 92
Grade: A
Feedback: Excellent! Outstanding performance.


Report Card
-----------
Student: Bob
Subject: Science
Marks: 78
Grade: C
Feedback: Good work! Average performance.


Report Card
-----------
Student: Charlie
Subject: History
Marks: 45
Grade: F
Feedback: Needs improvement. Please study more.

Report for David: Invalid marks: not a number

Novos Recursos Explicados

Vamos examinar os aprimoramentos que implementamos:

  1. Feedback Personalizado: Cada nota agora inclui uma mensagem de feedback específica que fornece contexto e incentivo.

  2. Formato de Retorno: Nossa função get_grade_with_feedback() retorna uma tupla contendo a nota e a mensagem de feedback.

  3. Formatação do Relatório: Criamos uma nova função format_report() que gera um boletim escolar bem estruturado para cada aluno.

  4. Teste com Dados do Mundo Real: Usamos uma lista de dicionários para simular dados reais de alunos, que é uma estrutura de dados comum em programação.

  5. Tratamento de Erros Adequado: O sistema ainda lida com entradas inválidas de forma adequada, mas agora apresenta os erros em um formato amigável para o usuário.

Esses aprimoramentos tornam nosso sistema de avaliação mais prático para uso no mundo real. O feedback personalizado ajuda os alunos a entender seu desempenho, enquanto o relatório formatado fornece uma apresentação profissional dos resultados.

Aplicando o Sistema de Avaliação a um Conjunto de Dados Real

Agora, vamos aplicar nosso sistema de avaliação a um cenário mais realista. Criaremos um programa que lê dados de alunos de um arquivo, calcula as notas e escreve um relatório abrangente.

Criando um Conjunto de Dados de Amostra

Primeiro, vamos criar um arquivo com dados de alunos de amostra. Crie um novo arquivo chamado student_data.csv no diretório /home/labex/project com o seguinte conteúdo:

name,subject,marks
John,Mathematics,88
Emily,Mathematics,92
Michael,Mathematics,75
Sophia,Mathematics,68
Daniel,Mathematics,42
Olivia,Mathematics,95
William,Mathematics,73
Emma,Mathematics,60
James,Mathematics,79
Ava,Mathematics,85

Criando a Aplicação de Avaliação Completa

Agora, crie um novo arquivo chamado grading_application.py no diretório /home/labex/project:

def get_grade_with_feedback(marks):
    """
    Convert numerical marks to letter grades with personalized feedback.

    Returns a tuple containing the grade and a feedback message.
    """
    try:
        marks = float(marks)

        if marks < 0 or marks > 100:
            return (None, "Invalid marks: must be between 0 and 100")
        elif marks >= 90:
            return ('A', "Excellent! Outstanding performance.")
        elif marks >= 80:
            return ('B', "Very good! Above average performance.")
        elif marks >= 70:
            return ('C', "Good work! Average performance.")
        elif marks >= 60:
            return ('D', "Satisfactory. Below average but passing.")
        else:
            return ('F', "Needs improvement. Please study more.")
    except ValueError:
        return (None, "Invalid marks: not a number")

def process_student_data(input_filename, output_filename):
    """
    Process student data from a CSV file and generate a report.
    """
    try:
        ## Read the input file
        with open(input_filename, 'r') as file:
            lines = file.readlines()

        ## Skip the header line
        headers = lines[0].strip().split(',')
        data = [line.strip().split(',') for line in lines[1:]]

        ## Prepare the output
        output_lines = ["Student Grade Report\n", "=" * 20 + "\n\n"]

        ## Calculate statistics
        valid_marks = []
        grade_counts = {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'F': 0, 'Invalid': 0}

        ## Process each student
        for student in data:
            name, subject, marks = student
            grade, feedback = get_grade_with_feedback(marks)

            if grade:
                valid_marks.append(float(marks))
                grade_counts[grade] += 1

                output_lines.append(f"Student: {name}\n")
                output_lines.append(f"Subject: {subject}\n")
                output_lines.append(f"Marks: {marks}\n")
                output_lines.append(f"Grade: {grade}\n")
                output_lines.append(f"Feedback: {feedback}\n\n")
            else:
                grade_counts['Invalid'] += 1
                output_lines.append(f"Student: {name}\n")
                output_lines.append(f"Subject: {subject}\n")
                output_lines.append(f"Error: {feedback}\n\n")

        ## Calculate statistics
        if valid_marks:
            average_mark = sum(valid_marks) / len(valid_marks)
            max_mark = max(valid_marks)
            min_mark = min(valid_marks)

            output_lines.append("Class Statistics\n")
            output_lines.append("-" * 15 + "\n")
            output_lines.append(f"Average Mark: {average_mark:.2f}\n")
            output_lines.append(f"Highest Mark: {max_mark:.1f}\n")
            output_lines.append(f"Lowest Mark: {min_mark:.1f}\n\n")

            output_lines.append("Grade Distribution\n")
            output_lines.append("-" * 17 + "\n")
            for grade, count in grade_counts.items():
                output_lines.append(f"{grade}: {count}\n")

        ## Write the output file
        with open(output_filename, 'w') as file:
            file.writelines(output_lines)

        print(f"Report successfully generated and saved to {output_filename}")

    except Exception as e:
        print(f"An error occurred: {str(e)}")

## Run the application
input_file = "/home/labex/project/student_data.csv"
output_file = "/home/labex/project/grade_report.txt"

process_student_data(input_file, output_file)

## Display the report in the console as well
print("\nGenerated Report Contents:")
print("--------------------------")
with open(output_file, 'r') as file:
    print(file.read())

Executando a Aplicação Completa

Execute a aplicação:

python3 /home/labex/project/grading_application.py

O programa lerá os dados dos alunos, calculará as notas, gerará um relatório e o exibirá no console. Você deve ver uma saída semelhante a:

Report successfully generated and saved to /home/labex/project/grade_report.txt

Generated Report Contents:
--------------------------
Student Grade Report
====================

Student: John
Subject: Mathematics
Marks: 88
Grade: B
Feedback: Very good! Above average performance.

Student: Emily
Subject: Mathematics
Marks: 92
Grade: A
Feedback: Excellent! Outstanding performance.

...

Class Statistics
---------------
Average Mark: 75.70
Highest Mark: 95.0
Lowest Mark: 42.0

Grade Distribution
-----------------
A: 2
B: 2
C: 3
D: 1
F: 2
Invalid: 0

Examinando o Arquivo de Relatório

Você também pode verificar o arquivo de relatório gerado:

cat /home/labex/project/grade_report.txt

O arquivo deve conter o mesmo conteúdo que foi exibido no console.

Compreendendo a Aplicação Completa

A aplicação de avaliação completa que criamos demonstra vários conceitos importantes de programação:

  1. I/O de Arquivo (File I/O): Leitura de dados de e escrita de dados em arquivos
  2. Processamento de Dados: Conversão e análise de dados brutos
  3. Cálculo de Estatísticas: Cálculo de médias e localização de valores mínimo/máximo
  4. Tratamento de Erros: Gerenciamento de erros potenciais durante operações de arquivo
  5. Formatação de Saída: Criação de um relatório bem estruturado e legível

Esta aplicação representa um caso de uso do mundo real para nosso sistema de avaliação, mostrando como as instruções if-elif-else do Python podem ser aplicadas para resolver problemas práticos em ambientes educacionais.

Resumo

Neste tutorial, você construiu com sucesso um sistema de avaliação abrangente usando as instruções if-elif-else do Python. Começando com instruções condicionais básicas, você aprimorou progressivamente seu programa para lidar com casos extremos, fornecer feedback personalizado e processar dados reais de alunos.

Aqui estão as principais habilidades que você desenvolveu:

  1. Usar instruções if-elif-else para implementar lógica de tomada de decisão
  2. Validar a entrada do usuário e lidar com erros de forma adequada
  3. Fornecer feedback significativo com base nas condições
  4. Processar dados de arquivos e gerar relatórios
  5. Calcular estatísticas de um conjunto de dados

Essas habilidades são fundamentais para muitas tarefas de programação e podem ser aplicadas a vários cenários do mundo real além dos sistemas de avaliação. Os princípios da lógica condicional que você aprendeu servirão como blocos de construção para programas mais complexos em seus futuros projetos Python.

Lembre-se de que as boas práticas de programação incluem:

  • Nomes de variáveis e funções claros e descritivos
  • Tratamento adequado de erros
  • Código bem estruturado e organizado
  • Comentários e documentação úteis

Continue praticando, estendendo este sistema de avaliação ou aplicando o que você aprendeu a novos desafios de programação!