Création d'un graphique à barres horizontales de percentiles

Introduction

Dans ce laboratoire, nous allons apprendre à créer un graphique à barres horizontales en utilisant la bibliothèque Matplotlib de Python. Nous prendrons l'exemple d'instructeurs de gym qui souhaitent montrer aux parents les résultats de leur enfant dans plusieurs tests de condition physique par rapport à ceux des autres enfants. Nous allons inventer des données pour le petit Johnny Doe afin d'extraire le code de tracé à des fins de démonstration.

Conseils pour la machine virtuelle (VM)

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer sur l'onglet Notebook et accéder à Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes que Jupyter Notebook ait terminé de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes lors de votre apprentissage, n'hésitez pas à demander de l'aide à Labby. Donnez votre avis après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Nous commençons par importer les bibliothèques nécessaires. Nous utiliserons numpy pour créer nos données et matplotlib.pyplot pour tracer notre graphique.

import matplotlib.pyplot as plt
import numpy as np

Définition des données

Nous définissons nos données en utilisant des tuples nommés. Nous définissons un tuple Student avec le nom de l'étudiant, sa classe et son genre. Nous définissons également un tuple Score avec la valeur du score, l'unité et le percentile.

from collections import namedtuple

Student = namedtuple('Student', ['name', 'grade', 'gender'])
Score = namedtuple('Score', ['value', 'unit', 'percentile'])

Définition des fonctions auxiliaires

Nous définissons deux fonctions auxiliaires. La première fonction, to_ordinal, convertit un entier en une chaîne de caractères ordinale (par exemple, 2 -> '2ème'). La deuxième fonction, format_score, crée des étiquettes de score pour l'axe des ordonnées droit sous la forme du nom du test suivi de l'unité de mesure (le cas échéant), réparties sur deux lignes.

def to_ordinal(num):
    suffixes = {str(i): v
                for i, v in enumerate(['th', 'st', 'nd', 'rd', 'th',
                                       'th', 'th', 'th', 'th', 'th'])}
    v = str(num)
    if v in {'11', '12', '13'}:
        return v + 'th'
    return v + suffixes[v[-1]]

def format_score(score):
    return f'{score.value}\n{score.unit}' if score.unit else str(score.value)

Définition de la fonction de tracé

Nous définissons une fonction appelée plot_student_results qui prend en entrée un tuple Student, un dictionnaire de scores par test et la taille de la cohorte. Cette fonction crée un graphique à barres horizontales des classements percentiles pour chaque test, par rapport à la cohorte de la classe et du genre de l'étudiant.

def plot_student_results(student, scores_by_test, cohort_size):
    fig, ax1 = plt.subplots(figsize=(9, 7), layout='constrained')
    fig.canvas.manager.set_window_title('Fitness Chart')

    ax1.set_title(student.name)
    ax1.set_xlabel(
        'Percentile Ranking Across {grade} Grade {gender}s\n'
        'Cohort Size: {cohort_size}'.format(
            grade=to_ordinal(student.grade),
            gender=student.gender.title(),
            cohort_size=cohort_size))

    test_names = list(scores_by_test.keys())
    percentiles = [score.percentile for score in scores_by_test.values()]

    rects = ax1.barh(test_names, percentiles, align='center', height=0.5)

    large_percentiles = [to_ordinal(p) if p > 40 else '' for p in percentiles]
    small_percentiles = [to_ordinal(p) if p <= 40 else '' for p in percentiles]
    ax1.bar_label(rects, small_percentiles,
                  padding=5, color='black', fontweight='bold')
    ax1.bar_label(rects, large_percentiles,
                  padding=-32, color='white', fontweight='bold')

    ax1.set_xlim([0, 100])
    ax1.set_xticks([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
    ax1.xaxis.grid(True, linestyle='--', which='major',
                   color='grey', alpha=.25)
    ax1.axvline(50, color='grey', alpha=0.25)

    ax2 = ax1.twinx()
    ax2.set_ylim(ax1.get_ylim())
    ax2.set_yticks(
        np.arange(len(scores_by_test)),
        labels=[format_score(score) for score in scores_by_test.values()])

    ax2.set_ylabel('Test Scores')

Définition des données pour le tracé

Nous définissons les données pour le tracé en utilisant les tuples nommés que nous avons définis précédemment. Nous créons un tuple Student pour Johnny Doe et un dictionnaire de tuples Score pour chaque test.

student = Student(name='Johnny Doe', grade=2, gender='Boy')
scores_by_test = {
    'Pacer Test': Score(7, 'laps', percentile=37),
    'Flexed Arm\n Hang': Score(48, 'sec', percentile=95),
    'Mile Run': Score('12:52', 'min:sec', percentile=73),
    'Agility': Score(17, 'sec', percentile=60),
    'Push Ups': Score(14, '', percentile=16),
}

Tracer les données

Nous appelons la fonction plot_student_results en utilisant les données de l'étudiant, les scores par test et la taille de la cohorte comme arguments, puis nous appelons plt.show() pour afficher le graphique.

plot_student_results(student, scores_by_test, cohort_size=62)
plt.show()

Résumé

Dans ce laboratoire, nous avons appris à créer un graphique à barres horizontales en utilisant la bibliothèque Matplotlib de Python. Nous avons utilisé l'exemple d'instructeurs de gym qui souhaitent montrer aux parents les résultats de leur enfant dans plusieurs tests de condition physique par rapport à ceux d'autres enfants. Nous avons défini nos données en utilisant des tuples nommés et nous avons défini des fonctions auxiliaires pour convertir des entiers en chaînes de caractères ordinales et pour créer des étiquettes de score pour l'axe des ordonnées droit. Nous avons défini une fonction de tracé qui crée un graphique à barres horizontales des classements percentiles pour chaque test, par rapport à la cohorte de la classe et du genre de l'étudiant. Ensuite, nous avons appelé la fonction de tracé avec nos données et affiché le graphique.