Créer un carnet de notes avec Pandas – Real Python

Chargement du fichier de liste

Vous êtes maintenant prêt à charger les données, en commençant par la liste:

ICI = Chemin(__fichier__).parent
DATA_FOLDER = ICI / "Les données"

liste = pd.read_csv(
    DATA_FOLDER / "roster.csv",
    convertisseurs="NetID": str.inférieur, "Adresse électronique": str.inférieur,
    usecols=[[[["Section", "Adresse électronique", "NetID"],
    index_col="NetID",
)

Dans ce code, vous créez deux constantes, ICI et DATA_FOLDER, pour garder une trace de l'emplacement du fichier en cours d'exécution ainsi que du dossier dans lequel les données sont stockées. Ces constantes utilisent le pathlib pour faciliter la consultation de différents dossiers.

Ensuite, vous lisez le fichier de liste en utilisant pd.read_csv (). Pour aider à traiter les données ultérieurement, vous définissez un index à l'aide de index_col et inclure uniquement les colonnes utiles avec usecols.

Pour vous assurer de pouvoir comparer les chaînes ultérieurement, vous passez également convertisseurs argument pour convertir les colonnes en minuscules. Cela simplifiera les comparaisons de chaînes que vous ferez plus tard.

Vous pouvez voir certaines des données dans le liste DataFrame ci-dessous:

Ce sont les quatre premières lignes de liste, et ils correspondent aux lignes de la table de liste que vous avez consultée dans la section précédente. Cependant, le NetID et Adresse électronique les colonnes ont toutes deux été converties en chaînes minuscules car vous avez réussi str.lower à convertisseurs pour ces deux colonnes. Vous avez également omis le Nom et Identifiant Colonnes.

Chargement du fichier de devoirs et d'examen

Ensuite, vous pouvez charger le fichier CSV des devoirs et des notes d'examen. N'oubliez pas que ce fichier comprend le prénom et le nom et la colonne SID en plus de toutes les notes. Vous souhaitez ignorer les colonnes avec les heures de soumission:

hw_exam_grades = pd.read_csv(
    DATA_FOLDER / "hw_exam_grades.csv",
    convertisseurs="SID": str.inférieur,
    usecols=lambda X: "Soumission" ne pas dans X,
    index_col="SID",
)

Dans ce code, vous utilisez à nouveau le convertisseurs argument pour convertir les données dans le SID et Adresse électronique colonnes en minuscules. Bien que les données de ces colonnes semblent être en minuscules lors de la première inspection, la meilleure pratique consiste à s'assurer que tout est cohérent. Vous devez également spécifier SID comme colonne d'index pour correspondre à la liste Trame de données.

Dans ce fichier CSV, il existe un certain nombre de colonnes contenant les heures de soumission des affectations que vous n'utiliserez dans aucune autre analyse. Cependant, il y a tellement d'autres colonnes que vous souhaitez conserver qu'il serait fastidieux de toutes les énumérer explicitement.

Pour contourner cela, usecols accepte également les fonctions appelées avec un seul argument, le nom de la colonne. Si la fonction retourne Vrai, la colonne est incluse. Sinon, la colonne est exclue. Avec le lambda fonction que vous passez ici, si la chaîne "Soumission" apparaît dans le nom de la colonne, la colonne sera exclue.

Voici un échantillon des hw_exam_grades DataFrame pour vous donner une idée de l'apparence des données après leur chargement:

Ce sont les lignes des exemples d'élèves dans le fichier CSV des devoirs et des notes d'examen que vous avez vu dans la section précédente. Notez que les données manquantes pour Traci Joyce (SID txj12345) dans le Devoirs 1 la colonne a été lue comme nanou Pas un nombre, valeur. Vous verrez comment gérer ce type de données dans une section ultérieure. Les ellipses (...) indiquent des colonnes de données qui ne figurent pas dans l'exemple ici mais qui sont chargées à partir des données réelles.

Chargement des fichiers de quiz

Enfin, vous devez charger les données des quiz. Il y a cinq questionnaires que vous devez lire, et la forme la plus utile de ces données est un DataFrame unique plutôt que cinq DataFrames distincts. Le format de données final ressemblera à ceci:

Ce DataFrame a le Email colonne comme index, et chaque quiz est dans une colonne distincte. Notez que les questionnaires sont hors service, mais vous verrez quand vous calculerez les notes finales que la commande n'a pas d'importance. Vous pouvez utiliser ce code pour charger les fichiers de quiz:

quiz_grades = pd.Trame de données()
pour chemin du fichier dans DATA_FOLDER.glob("quiz _ * _ grades.csv"):
    quiz_name = "".joindre(chemin du fichier.tige.Titre().Divisé("_")[:[:[:[:2])
    quiz = pd.read_csv(
        chemin du fichier,
        convertisseurs="Email": str.inférieur,
        index_col=[[[["Email"],
        usecols=[[[["Email", "Classe"],
    ).Renommer(Colonnes="Classe": quiz_name)
    quiz_grades = pd.concat([[[[quiz_grades, quiz], axe=1)

Dans ce code, vous créez un DataFrame vide appelé quiz_grades. Vous avez besoin du DataFrame vide pour la même raison que vous devez créer une liste vide avant d'utiliser list.append ().

Tu utilises Path.glob () pour trouver tous les fichiers CSV du quiz et les charger avec des pandas, en veillant à convertir les adresses e-mail en minuscules. Vous définissez également la colonne d'index pour chaque quiz sur les adresses e-mail des étudiants, qui pd.concat () utilise pour aligner les données de chaque élève.

Remarquez que vous passez axe = 1 à pd.concat (). Cela oblige les pandas à concaténer des colonnes plutôt que des lignes, en ajoutant chaque nouveau quiz dans une nouvelle colonne dans le DataFrame combiné.

Enfin, vous utilisez DataFrame.rename () pour changer le nom de la colonne de notes de Classe à quelque chose de spécifique à chaque quiz.

Fusionner la liste et les devoirs

Dans liste et hw_exam_grades, vous avez la colonne NetID ou SID comme identifiant unique pour un étudiant donné. Lorsque vous fusionnez ou rejoignez des DataFrames dans des pandas, il est très utile d'avoir un index. Vous avez déjà vu à quel point cela était utile lorsque vous chargiez les fichiers de quiz.

N'oubliez pas que vous avez réussi le index_col argument à pd.read_csv () lorsque vous avez chargé la liste et les notes de devoirs. Vous pouvez maintenant fusionner ces deux DataFrames ensemble:

final_data = pd.fusionner(
    liste, hw_exam_grades, left_index=Vrai, right_index=Vrai,
)

Dans ce code, vous utilisez pd.merge () pour combiner le liste et hw_exam_grades DataFrames.

Voici un exemple du DataFrame fusionné pour les quatre exemples d'étudiants:

Comme vous l'avez vu précédemment, les ellipses indiquent des colonnes qui ne sont pas affichées dans l'exemple ici mais qui sont présentes dans le DataFrame réel. L'exemple de tableau montre que les élèves ayant le même NetID ou SID ont été fusionnés, de sorte que leurs adresses e-mail et notes de devoirs 1 correspondent aux tableaux que vous avez vus précédemment.

Fusion des notes du quiz

Lorsque vous avez chargé les données pour le quiz_grades, vous avez utilisé l'adresse e-mail comme identifiant unique pour chaque élève. C'est différent de hw_exam_grades et liste, qui utilisaient respectivement le NetID et le SID.

Fusionner quiz_grades dans final_data, vous pouvez utiliser l'index à partir de quiz_grades et le Adresse électronique colonne de final_data:

final_data = pd.fusionner(
    final_data, quiz_grades, à gauche sur="Adresse électronique", right_index=Vrai
)

Dans ce code, vous utilisez le à gauche sur argument à pd.merge () pour dire aux pandas d'utiliser le Adresse électronique colonne dans final_data dans la fusion. Vous utilisez également right_index pour dire aux pandas d'utiliser l'index de quiz_grades dans la fusion.

Voici un échantillon du DataFrame fusionné montrant les quatre exemples d'étudiants:

N'oubliez pas que les ellipses signifient que des colonnes sont manquantes dans l'exemple de table ici mais seront présentes dans le DataFrame fusionné. Vous pouvez revérifier les tableaux précédents pour vérifier que les nombres sont alignés pour les bons élèves.

Remplir nan Valeurs

Maintenant, toutes vos données sont fusionnées en un seul DataFrame. Avant de pouvoir passer au calcul des notes, vous devez effectuer un nettoyage supplémentaire des données.

Vous pouvez voir dans le tableau ci-dessus que Traci Joyce a toujours un nan valeur pour son devoir de devoirs 1. Vous ne pouvez pas utiliser nan valeurs dans les calculs parce que, eh bien, ce ne sont pas un nombre! Vous pouvez utiliser DataFrame.fillna () d'attribuer un numéro à tous les nan valeurs en final_data:

final_data = final_data.fillna(0)

Dans ce code, vous utilisez DataFrame.fillna () pour tout remplir nan valeurs en final_data avec la valeur 0. Il s'agit d'une résolution appropriée car le nan dans la colonne Devoirs de Traci Joyce 1 indique que le score est manquant, ce qui signifie qu'elle n'a probablement pas remis le devoir.

Voici un échantillon du DataFrame modifié montrant les quatre exemples d'étudiants:

Comme vous pouvez le voir dans ce tableau, le score de Traci Joyce Homework 1 est désormais 0 au lieu de nan, mais les notes des autres étudiants n'ont pas changé.

Calcul du score total à l'examen

Vous calculerez d'abord les notes des examens. Étant donné que chaque examen a un poids unique, vous pouvez calculer le score total pour chaque examen individuellement. Il est plus judicieux d'utiliser un pour boucle, que vous pouvez voir dans ce code:

n_exams = 3
pour n dans gamme(1, n_exams + 1):
    final_data[[[[F"Examen n    But"] = (
        final_data[[[[F"Examen n"] / final_data[[[[F"Examen n    - Max Points "]
    )

Dans ce code, vous définissez n_exams égal à 3 parce que vous avez passé trois examens pendant le trimestre. Ensuite, vous parcourez chaque examen pour calculer le score en divisant le score brut par le nombre maximal de points pour cet examen.

Voici un échantillon des données d'examen pour les quatre exemples d'étudiants:

Dans ce tableau, chaque élève a obtenu entre 0,0 et 1,0 pour chacun des examens. À la fin de votre script, vous multipliez ces scores par le poids pour déterminer la proportion de la note finale.

Calcul des scores de devoirs

Ensuite, vous devez calculer les scores des devoirs. Le nombre maximal de points pour chaque devoir varie de 50 à 100. Cela signifie qu'il existe deux façons de calculer le score des devoirs:

1. Par score total: Additionnez les scores bruts et les points maximum indépendamment, puis prenez le rapport.
2. Par score moyen: Divisez chaque score brut par ses points maximums respectifs, puis prenez la somme de ces ratios et divisez le total par le nombre d'affectations.

La première méthode donne un score plus élevé aux élèves qui ont obtenu des résultats constants, tandis que la deuxième méthode favorise les élèves qui ont bien réussi les travaux qui valaient plus de points. Pour aider les étudiants, vous leur donnerez le maximum de ces deux scores.

Le calcul de ces scores prendra quelques étapes:

1. Collectez les colonnes avec des données de devoirs.
2. Calculez le score total.
3. Calculez le score moyen.
4. Déterminez quel score est le plus grand et sera utilisé dans le calcul du score final.

Tout d'abord, vous devez collecter toutes les colonnes avec des données de devoirs. Vous pouvez utiliser DataFrame.filter () pour faire ça:

devoirs_scores = final_data.filtre(regex=r"^ Devoirs  d  d? $", axe=1)
homework_max_points = final_data.filtre(regex=r"^ Devoirs  d  d? -", axe=1)

Dans ce code, vous utilisez une expression régulière (regex) pour filtrer final_data. Si un nom de colonne ne correspond pas à l'expression régulière, la colonne ne sera pas incluse dans le DataFrame résultant.

L'autre argument auquel vous passez DataFrame.filter () est axe. De nombreuses méthodes d'un DataFrame peuvent fonctionner en ligne ou en colonne, et vous pouvez basculer entre les deux approches à l'aide de la axe argument. Avec l'argument par défaut axe = 0, les pandas rechercheraient dans l'index des lignes correspondant à l'expression régulière que vous avez transmise. Puisque vous voulez trouver tous les Colonnes qui correspondent à l'expression rationnelle à la place, vous passez axe = 1.

Maintenant que vous avez collecté les colonnes dont vous avez besoin à partir du DataFrame, vous pouvez effectuer les calculs avec elles. Tout d'abord, vous additionnez les deux valeurs indépendamment, puis vous les divisez pour calculer le score total des devoirs:

sum_of_hw_scores = devoirs_scores.somme(axe=1)
sum_of_hw_max = homework_max_points.somme(axe=1)
final_data[[[["Total devoirs"] = sum_of_hw_scores / sum_of_hw_max

Dans ce code, vous utilisez DataFrame.sum () et passer le axe argument. Par défaut, .somme() additionnera les valeurs de toutes les lignes de chaque colonne. Cependant, vous voulez la somme de toutes les colonnes pour chaque ligne car chaque ligne représente un étudiant. le axe = 1 l'argument dit aux pandas de faire exactement cela.

Ensuite, vous affectez une nouvelle colonne dans final_data appelé Total devoirs au rapport des deux sommes.

Voici un exemple des résultats du calcul pour les quatre exemples d'élèves:

Dans ce tableau, vous pouvez voir la somme des scores des devoirs, la somme des scores max et le score total des devoirs pour chaque élève.

L'autre méthode de calcul consiste à diviser chaque score de devoirs par son score maximum, à additionner ces valeurs et à diviser le total par le nombre de devoirs. Pour ce faire, vous pouvez utiliser un pour boucle et parcourez chaque colonne. Cependant, pandas vous permet d'être plus efficace car il correspondra aux étiquettes de colonne et d'index et effectuera des opérations mathématiques uniquement sur les étiquettes correspondantes.

Pour que cela fonctionne, vous devez modifier les noms de colonne pour homework_max_points pour faire correspondre les noms devoirs_scores. Vous pouvez le faire en utilisant DataFrame.set_axis ():

hw_max_renamed = homework_max_points.set_axis(devoirs_scores.Colonnes, axe=1)

Dans ce code, vous créez un nouveau DataFrame, hw_max_renamedet vous définissez les colonnes axe d'avoir les mêmes noms que les colonnes devoirs_scores. Vous pouvez maintenant utiliser ce DataFrame pour plus de calculs:

average_hw_scores = (devoirs_scores / hw_max_renamed).somme(axe=1)

Dans ce code, vous calculez la average_hw_scores en divisant chaque score de devoirs par ses points maximums respectifs. Ensuite, vous additionnez les ratios pour toutes les affectations de devoirs dans chaque ligne avec DataFrame.sum () et l'argument axe = 1.

Étant donné que la valeur maximale pour chaque devoir individuel est de 1,0, la valeur maximale que cette somme pourrait prendre serait égale au nombre total de devoirs. Cependant, vous avez besoin d'un nombre qui va de 0 à 1 pour prendre en compte la note finale.

Cela signifie que vous devez diviser average_hw_scores par le nombre d'affectations que vous pouvez faire avec ce code:

final_data[[[["Devoirs moyens"] = average_hw_scores / devoirs_scores.forme[[[[1]

Dans ce code, vous utilisez DataFrame.shape pour obtenir le nombre d'affectations de devoirs_scores. Comme un tableau NumPy, DataFrame.shape renvoie un tuple de (n_rows, n_columns). Prendre la deuxième valeur du tuple vous donne le nombre de colonnes dans devoirs_scores, qui est égal au nombre d'affectations.

Ensuite, vous affectez le résultat de la division à une nouvelle colonne dans final_data appelé Devoirs moyens.

Voici un exemple de résultat de calcul pour les quatre exemples d'étudiants:

Dans ce tableau, notez que le Somme des notes moyennes des devoirs peut varier de 0 à 10, mais le Devoirs moyens varie de 0 à 1. La deuxième colonne sera utilisée pour comparer à Total devoirs suivant.

Maintenant que vous avez calculé vos deux notes de devoirs, vous pouvez prendre la valeur maximale à utiliser dans le calcul de la note finale:

final_data[[[["Score de devoirs"] = final_data[[[[
    [[[["Total devoirs", "Devoirs moyens"]
].max(axe=1)

Dans ce code, vous sélectionnez les deux colonnes que vous venez de créer, Total devoirs et Devoirs moyenset attribuez la valeur maximale à une nouvelle colonne appelée Score de devoirs. Notez que vous prenez le maximum pour chaque élève avec axe = 1.

Voici un échantillon des résultats calculés pour les quatre exemples d'étudiants:

Dans ce tableau, vous pouvez comparer les Total devoirs, Devoirs moyenset final Score de devoirs Colonnes. Vous pouvez voir que le Score de devoirs reflète toujours le plus grand des Total devoirs ou Devoirs moyens.

Calcul du score du quiz

Ensuite, vous devez calculer le score du quiz. Les questionnaires ont également différents nombres de points maximum, vous devez donc faire la même procédure que vous avez faite pour les devoirs. La seule différence est que la note maximale de chaque questionnaire n'est pas spécifiée dans les tableaux de données du questionnaire, vous devez donc créer une série pandas pour contenir ces informations:

quiz_scores = final_data.filtre(regex=r"^ Quiz  d $", axe=1)
quiz_max_points = pd.Séries(
    "Quiz 1": 11, "Quiz 2": 15, "Quiz 3": 17, "Quiz 4": 14, "Quiz 5": 12
)

sum_of_quiz_scores = quiz_scores.somme(axe=1)
sum_of_quiz_max = quiz_max_points.somme()
final_data[[[["Total des quiz"] = sum_of_hw_scores / sum_of_hw_max

average_quiz_scores = (quiz_scores / quiz_max_points).somme(axe=1)
final_data[[[["Quiz moyens"] = average_quiz_scores / quiz_scores.forme[[[[1]

final_data[[[["Score du quiz"] = final_data[[[[
    [[[["Total des quiz", "Quiz moyens"]
].max(axe=1)

La plupart de ce code est assez similaire au code des devoirs de la dernière section. La principale différence avec le cas des devoirs est que vous avez créé une série pandas pour quiz_max_points en utilisant un dictionnaire comme entrée. Les clés du dictionnaire deviennent des étiquettes d'index et les valeurs du dictionnaire deviennent les valeurs de série.

Étant donné que les étiquettes d'index dans quiz_max_points avoir les mêmes noms que quiz_scores, vous n'avez pas besoin d'utiliser DataFrame.set_axis () pour les quiz. pandas aussi émissions la forme d'une série afin qu'elle corresponde au DataFrame.

Voici un exemple du résultat de ce calcul pour les quiz:

Dans ce tableau, le Score du quiz est toujours le plus grand de Total des quiz ou Quiz moyens, comme prévu.

Calcul de la note de la lettre

Vous avez maintenant terminé tous les calculs requis pour la note finale. Vous avez des scores pour les examens, les devoirs et les questionnaires qui sont tous échelonnés entre 0 et 1. Ensuite, vous devez multiplier chaque score par sa pondération pour déterminer la note finale. Ensuite, vous pouvez mapper cette valeur sur une échelle pour les notes alphabétiques, de A à F.

Comme pour les scores de quiz maximaux, vous utiliserez une série pandas pour stocker les pondérations. De cette façon, vous pouvez multiplier par les colonnes correctes de final_data automatiquement. Créez vos pondérations avec ce code:

pondérations = pd.Séries(
    
        "Score de l'examen 1": 0,05,
        "Score de l'examen 2": 0,1,
        "Score de l'examen 3": 0,15,
        "Score du quiz": 0,30,
        "Score de devoirs": 0,4,
    
)

Dans ce code, vous donnez une pondération à chaque composant de la classe. Comme vous l'avez vu plus tôt, Examen 1 vaut 5%, Examen 2 vaut 10%, Examen 3 vaut 15%, les quiz valent 30% et Devoirs vaut 40% de la note globale.

Ensuite, vous pouvez combiner ces pourcentages avec les scores que vous avez calculés précédemment pour déterminer le score final:

final_data[[[["Score final"] = (final_data[[[[pondérations.indice] * pondérations).somme(
    axe=1
)
final_data[[[["Score plafond"] = np.plafond(final_data[[[["Score final"] * 100)

Dans ce code, vous sélectionnez les colonnes de final_data qui ont les mêmes noms que l'index dans pondérations. Vous devez le faire car certaines des autres colonnes de final_data avoir un type str, donc les pandas Erreur-type si vous essayez de vous multiplier pondérations par tous final_data.

Ensuite, vous prenez la somme de ces colonnes pour chaque étudiant avec DataFrame.sum (axe = 1) et vous attribuez le résultat à une nouvelle colonne appelée Score final. La valeur de cette colonne pour chaque élève est un nombre à virgule flottante compris entre 0 et 1.

Enfin, étant le professeur vraiment sympa que vous êtes, vous allez arrondir la note de chaque élève. Vous multipliez chaque élève Score final par 100 pour le mettre sur une échelle de 0 à 100, vous utilisez numpy.ceil () pour arrondir chaque score à l'entier le plus élevé suivant. Vous affectez cette valeur à une nouvelle colonne appelée Score plafond.

Voici un exemple de résultat de calcul pour ces colonnes pour les quatre exemples d'étudiants:

La dernière chose à faire est de mapper le score plafond de chaque élève sur une note de lettre. Dans votre école, vous pouvez utiliser les notes suivantes:

• UNE: Score de 90 ou plus
• B: Score entre 80 et 90
• C: Score entre 70 et 80
• ré: Score entre 60 et 70
• F: Score inférieur à 60

Étant donné que chaque note de lettre doit correspondre à une plage de scores, vous ne pouvez pas facilement utiliser simplement un dictionnaire pour le mappage. Heureusement, les pandas ont Series.map (), qui vous permet d'appliquer une fonction arbitraire aux valeurs d'une série. Vous pourriez faire quelque chose de similaire si vous utilisiez une échelle de notation différente de celle des lettres.

Vous pouvez écrire une fonction appropriée de cette façon:

grades = 
    90: "UNE",
    80: "B",
    70: "C",
    60: "RÉ",
    0: "F",


def grade_mapping(valeur):
    pour clé, lettre dans grades.articles():
        si valeur > = clé:
            revenir lettre

Dans ce code, vous créez un dictionnaire qui stocke le mappage entre la limite inférieure de chaque grade de lettre et la lettre. Ensuite, vous définissez grade_mapping (), qui prend comme argument la valeur d'une ligne de la série de scores de plafond. Vous parcourez les éléments dans grades, comparant valeur à la clé from the dictionary. If value is greater than key, then the student falls in that bracket and you return the appropriate letter grade.

Avec grade_mapping() defined, you can use Series.map() to find the letter grades:

letter_grades = final_data[[[["Ceiling Score"].carte(grade_mapping)
final_data[[[["Final Grade"] = pd.Categorical(
    letter_grades, catégories=grades.valeurs(), ordered=Vrai
)

In this code, you create a new Series called letter_grades by mapping grade_mapping() onto the Ceiling Score column from final_data. Since there are five choices for a letter grade, it makes sense for this to be a categorical data type. Once you’ve mapped the scores to letters, you can create a categorical column with the pandas Categorical class.

To create the categorical column, you pass the letter grades as well as two keyword arguments:

1. catégories is passed the values from grades. The values in grades are the possible letter grades in the class.
2. ordered is passed Vrai to tell pandas that the categories are ordered. This will help later if you want to sort this column.

The categorical column that you create is assigned to a new column in final_data appelé Final Grade.

Here are the final grades for the four example students:

Among the four example students, two people got Bs and two people got Cs, matching their ceiling scores and the letter grade mapping you created.