LabEx
EntrerRejoindre

Comment déterminer une note en fonction des notes avec if-elif-else en Python

PythonBeginner
Pratiquer maintenant

Introduction

Ce tutoriel vous guidera à travers le processus de mise en œuvre d'un système de notation utilisant les instructions if-elif-else de Python. Vous apprendrez à déterminer la note d'un étudiant en fonction de ses notes, une tâche courante dans les établissements d'enseignement. À la fin de ce tutoriel, vous aurez créé un programme de notation fonctionnel qui peut être appliqué à des scénarios réels. Cette approche pratique renforcera votre compréhension des instructions conditionnelles en Python, qui sont des éléments fondamentaux pour une logique de programmation plus complexe.

Comprendre les instructions conditionnelles en Python

Avant de créer notre système de notation, comprenons les instructions conditionnelles de base en Python. Les instructions conditionnelles permettent à votre programme de prendre des décisions basées sur des conditions spécifiques.

Création de votre premier fichier Python

Commençons par créer un nouveau fichier Python :

  1. Dans le WebIDE, cliquez sur le menu "File" (Fichier) en haut à gauche.
  2. Sélectionnez "New File" (Nouveau fichier).
  3. Enregistrez le fichier sous le nom conditional_demo.py dans le répertoire /home/labex/project.

Instruction If-Else de base

Dans votre fichier conditional_demo.py, écrivez le code suivant :

## 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

Ce programme simple vérifie si la variable score est supérieure ou égale à 70. Si c'est le cas, il affiche "You passed the test!". Sinon, il affiche "You need to study more."

Tester votre code

Pour exécuter votre code, ouvrez un terminal dans le WebIDE et exécutez :

python3 /home/labex/project/conditional_demo.py

Vous devriez voir la sortie :

You passed the test!

Ajout de plus de conditions avec If-Elif-Else

Développons notre exemple pour gérer plus de conditions en utilisant la structure 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

Enregistrez le fichier et exécutez-le à nouveau :

python3 /home/labex/project/conditional_demo.py

Sortie :

You passed the test!
Very good!

La structure if-elif-else évalue les conditions de haut en bas. Une fois qu'une condition est vraie, son bloc de code correspondant s'exécute, et le reste des conditions est ignoré.

Comprendre ce flux est crucial pour construire notre système de notation à l'étape suivante.

Création d'un système de notation de base

Maintenant que nous comprenons les instructions conditionnelles, construisons un système de notation simple. Nous allons créer une fonction qui convertit les notes numériques en notes littérales.

Création du fichier du système de notation

  1. Dans le WebIDE, créez un nouveau fichier appelé grading_system.py
  2. Enregistrez-le dans le répertoire /home/labex/project

Implémentation de la fonction de notation de base

Dans votre fichier grading_system.py, écrivez le code suivant :

def get_grade(marks):
    """
    Convertir les notes numériques en notes littérales.

    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}")

Ce code crée une fonction get_grade() qui prend les notes d'un étudiant en entrée et renvoie la note littérale correspondante en fonction des seuils de notation courants.

Exécution de notre système de notation

Testons notre système de notation en exécutant le code :

python3 /home/labex/project/grading_system.py

Vous devriez voir une sortie similaire à :

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

Comprendre le code

Décomposons le fonctionnement :

  1. Nous avons défini une fonction appelée get_grade() qui prend un paramètre : marks (notes).
  2. À l'intérieur de la fonction, nous avons utilisé des instructions if-elif-else pour vérifier les notes par rapport à différents seuils de notation.
  3. Nous avons créé une liste de notes de test pour démontrer comment la fonction fonctionne avec différentes valeurs.
  4. Nous avons utilisé une boucle for pour itérer sur chaque note, obtenir sa note et afficher le résultat.

Ce système de notation de base fonctionne bien pour les cas standards, mais qu'en est-il des cas limites (edge cases) ? À l'étape suivante, nous améliorerons notre système pour les gérer.

Gestion des cas limites dans notre système de notation

Notre système de notation de base fonctionne, mais il ne tient pas compte des cas limites tels que :

  1. Saisies non valides (notes inférieures à 0 ou supérieures à 100)
  2. Saisies non numériques

Améliorons notre système de notation pour gérer ces scénarios.

Mise à jour du système de notation

Créez un nouveau fichier appelé improved_grading.py dans le répertoire /home/labex/project avec le code suivant :

def get_grade(marks):
    """
    Convertir les notes numériques en notes littérales avec validation des entrées.

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

    Retourne "Invalid marks" (Notes non valides) pour les entrées en dehors de la plage 0-100
    """
    try:
        ## Convertir en float au cas où l'entrée est un nombre sous forme de chaîne
        marks = float(marks)

        ## Vérifier si les notes sont dans la plage valide
        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}")

Exécution du système de notation amélioré

Exécutez le système de notation amélioré :

python3 /home/labex/project/improved_grading.py

La sortie devrait ressembler à :

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

Explication des améliorations

Examinons les améliorations que nous avons apportées :

  1. Conversion du type d'entrée : Nous utilisons float() pour convertir l'entrée en un nombre, ce qui permet à notre fonction d'accepter des entrées de type chaîne comme "75".

  2. Vérification de la plage valide : Nous avons ajouté une condition pour vérifier si les notes se situent dans la plage valide de 0 à 100.

  3. Gestion des erreurs : Nous avons enveloppé notre code dans un bloc try-except pour intercepter les exceptions ValueError qui se produisent lorsque des entrées non numériques sont fournies.

  4. Messages d'erreur détaillés : Nous renvoyons des messages d'erreur spécifiques pour informer l'utilisateur de ce qui s'est mal passé au lieu de simplement renvoyer un code d'erreur.

Ces améliorations rendent notre système de notation plus robuste en gérant gracieusement divers cas limites. Le programme fournit désormais des commentaires utiles lorsque des entrées non valides sont rencontrées, au lieu de planter ou de produire des résultats incorrects.

Amélioration du système de notation avec des messages de commentaires

Améliorons encore notre système de notation en ajoutant des messages de commentaires personnalisés pour chaque note. Cela rend le système plus informatif et convivial.

Création du système de notation amélioré

Créez un nouveau fichier appelé enhanced_grading.py dans le répertoire /home/labex/project :

def get_grade_with_feedback(marks):
    """
    Convertir les notes numériques en notes littérales avec des commentaires personnalisés.

    Retourne un tuple contenant la note et un message de commentaire.
    """
    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):
    """
    Générer un rapport formaté pour un étudiant.
    """
    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)

Exécution du système de notation amélioré

Exécutez le système de notation amélioré :

python3 /home/labex/project/enhanced_grading.py

Vous devriez voir une sortie similaire à :


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

Explication des nouvelles fonctionnalités

Examinons les améliorations que nous avons implémentées :

  1. Commentaires personnalisés : Chaque note comprend désormais un message de commentaire spécifique qui fournit un contexte et des encouragements.

  2. Format de retour : Notre fonction get_grade_with_feedback() renvoie un tuple contenant à la fois la note et le message de commentaire.

  3. Formatage du rapport : Nous avons créé une nouvelle fonction format_report() qui génère un bulletin de notes bien structuré pour chaque étudiant.

  4. Tests avec des données réelles : Nous avons utilisé une liste de dictionnaires pour simuler des données réelles d'étudiants, ce qui est une structure de données courante en programmation.

  5. Gestion gracieuse des erreurs : Le système gère toujours les entrées non valides avec élégance, mais présente désormais les erreurs dans un format convivial.

Ces améliorations rendent notre système de notation plus pratique pour une utilisation réelle. Les commentaires personnalisés aident les étudiants à comprendre leurs performances, tandis que le rapport formaté fournit une présentation professionnelle des résultats.

Application du système de notation à un ensemble de données réel

Appliquons maintenant notre système de notation à un scénario plus réaliste. Nous allons créer un programme qui lit les données des étudiants à partir d'un fichier, calcule les notes et écrit un rapport complet.

Création d'un exemple d'ensemble de données

Tout d'abord, créons un fichier avec des exemples de données d'étudiants. Créez un nouveau fichier appelé student_data.csv dans le répertoire /home/labex/project avec le contenu suivant :

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

Création de l'application de notation complète

Maintenant, créez un nouveau fichier appelé grading_application.py dans le répertoire /home/labex/project :

def get_grade_with_feedback(marks):
    """
    Convertir les notes numériques en notes littérales avec des commentaires personnalisés.

    Retourne un tuple contenant la note et un message de commentaire.
    """
    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):
    """
    Traiter les données des étudiants à partir d'un fichier CSV et générer un rapport.
    """
    try:
        ## Lire le fichier d'entrée
        with open(input_filename, 'r') as file:
            lines = file.readlines()

        ## Ignorer la ligne d'en-tête
        headers = lines[0].strip().split(',')
        data = [line.strip().split(',') for line in lines[1:]]

        ## Préparer la sortie
        output_lines = ["Student Grade Report\n", "=" * 20 + "\n\n"]

        ## Calculer les statistiques
        valid_marks = []
        grade_counts = {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'F': 0, 'Invalid': 0}

        ## Traiter chaque étudiant
        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")

        ## Calculer les statistiques
        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")

        ## Écrire le fichier de sortie
        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())

Exécution de l'application complète

Exécutez l'application :

python3 /home/labex/project/grading_application.py

Le programme lira les données des étudiants, calculera les notes, générera un rapport et l'affichera dans la console. Vous devriez voir une sortie similaire à :

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

Examen du fichier de rapport

Vous pouvez également vérifier le fichier de rapport généré :

cat /home/labex/project/grade_report.txt

Le fichier doit contenir le même contenu que celui affiché dans la console.

Compréhension de l'application complète

L'application de notation complète que nous avons créée démontre plusieurs concepts de programmation importants :

  1. Entrées/Sorties de fichiers (File I/O) : Lecture et écriture de données dans des fichiers
  2. Traitement des données (Data Processing) : Conversion et analyse des données brutes
  3. Calcul des statistiques (Statistics Calculation) : Calcul des moyennes et recherche des valeurs minimales/maximales
  4. Gestion des erreurs (Error Handling) : Gestion des erreurs potentielles lors des opérations sur les fichiers
  5. Formatage de la sortie (Formatting Output) : Création d'un rapport bien structuré et lisible

Cette application représente un cas d'utilisation réel de notre système de notation, montrant comment les instructions if-elif-else de Python peuvent être appliquées pour résoudre des problèmes pratiques dans les contextes éducatifs.

Résumé

Dans ce tutoriel, vous avez réussi à construire un système de notation complet en utilisant les instructions if-elif-else de Python. En commençant par les instructions conditionnelles de base, vous avez progressivement amélioré votre programme pour gérer les cas limites, fournir des commentaires personnalisés et traiter des données réelles d'étudiants.

Voici les compétences clés que vous avez développées :

  1. Utilisation des instructions if-elif-else pour implémenter une logique de prise de décision
  2. Validation des entrées utilisateur et gestion gracieuse des erreurs
  3. Fourniture de commentaires pertinents basés sur des conditions
  4. Traitement des données à partir de fichiers et génération de rapports
  5. Calcul de statistiques à partir d'un ensemble de données

Ces compétences sont fondamentales pour de nombreuses tâches de programmation et peuvent être appliquées à divers scénarios réels au-delà des systèmes de notation. Les principes de la logique conditionnelle que vous avez appris serviront de blocs de construction pour des programmes plus complexes dans vos futurs projets Python.

N'oubliez pas que les bonnes pratiques de programmation incluent :

  • Des noms de variables et de fonctions clairs et descriptifs
  • Une gestion appropriée des erreurs
  • Un code bien structuré et organisé
  • Des commentaires et une documentation utiles

Continuez à vous entraîner en étendant ce système de notation ou en appliquant ce que vous avez appris à de nouveaux défis de programmation !

Connexe Python Cours
Démarrage rapide avec Python

Démarrage rapide avec Python

python
Fiche de Référence Python

Fiche de Référence Python

python
Défis pratiques en Python

Défis pratiques en Python

python