Feuilles de style de Matplotlib

Introduction

Matplotlib est une puissante bibliothèque de visualisation de données en Python. Elle vous permet de créer diverses types de graphiques, tels que des graphiques de dispersion, des histogrammes, des diagrammes en barres, etc. Le script de référence des feuilles de style montre les différentes feuilles de style disponibles sur un ensemble commun de graphiques d'exemple. Dans ce laboratoire, vous allez apprendre à utiliser les feuilles de style Matplotlib pour personnaliser l'apparence de vos graphiques.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet d'adresses pour accéder au carnet Jupyter pour pratiquer.

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

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

Importation des bibliothèques

Avant de commencer, vous devez importer les bibliothèques nécessaires. Dans ce laboratoire, vous utiliserez Matplotlib et NumPy.

import matplotlib.pyplot as plt
import numpy as np

Définition des fonctions de tracé

Ensuite, vous devez définir les fonctions de tracé qui seront utilisées pour créer les graphiques d'exemple. Dans cette étape, vous définirez les fonctions de tracé suivantes :

• plot_scatter() : crée un graphique de dispersion
• plot_colored_lines() : trace des lignes avec des couleurs suivant le cycle de couleurs du style
• plot_bar_graphs() : crée un diagramme en barres
• plot_colored_circles() : trace des patches circulaires
• plot_image_and_patch() : trace une image avec une patch circulaire
• plot_histograms() : crée des histogrammes

def plot_scatter(ax, prng, nb_samples=100):
    """Graphique de dispersion."""
    for mu, sigma, marker in [(-.5, 0.75, 'o'), (0.75, 1.,'s')]:
        x, y = prng.normal(loc=mu, scale=sigma, size=(2, nb_samples))
        ax.plot(x, y, ls='none', marker=marker)
    ax.set_xlabel('Étiquette de l\'axe X')
    ax.set_title('Titre des axes')
    return ax


def plot_colored_lines(ax):
    """Trace des lignes avec des couleurs suivant le cycle de couleurs du style."""
    t = np.linspace(-10, 10, 100)

    def sigmoid(t, t0):
        return 1 / (1 + np.exp(-(t - t0)))

    nb_colors = len(plt.rcParams['axes.prop_cycle'])
    shifts = np.linspace(-5, 5, nb_colors)
    amplitudes = np.linspace(1, 1.5, nb_colors)
    for t0, a in zip(shifts, amplitudes):
        ax.plot(t, a * sigmoid(t, t0), '-')
    ax.set_xlim(-10, 10)
    return ax


def plot_bar_graphs(ax, prng, min_value=5, max_value=25, nb_samples=5):
    """Trace deux diagrammes en barres côte à côte, avec des lettres comme étiquettes d'axe x."""
    x = np.arange(nb_samples)
    ya, yb = prng.randint(min_value, max_value, size=(2, nb_samples))
    width = 0.25
    ax.bar(x, ya, width)
    ax.bar(x + width, yb, width, color='C2')
    ax.set_xticks(x + width, labels=['a', 'b', 'c', 'd', 'e'])
    return ax


def plot_colored_circles(ax, prng, nb_samples=15):
    """
    Trace des patches circulaires.

    NB : trace un nombre fixe d'échantillons, plutôt que d'utiliser la longueur
    du cycle de couleurs, car différents styles peuvent avoir un nombre différent
    de couleurs.
    """
    for sty_dict, j in zip(plt.rcParams['axes.prop_cycle'](),
                           range(nb_samples)):
        ax.add_patch(plt.Circle(prng.normal(scale=3, size=2),
                                radius=1.0, color=sty_dict['color']))
    ax.grid(visible=True)

    ## Ajoute un titre pour activer la grille
    plt.title('ax.grid(True)', family='monospace', fontsize='small')

    ax.set_xlim([-4, 8])
    ax.set_ylim([-5, 6])
    ax.set_aspect('equal', adjustable='box')  ## pour tracer les cercles comme des cercles
    return ax


def plot_image_and_patch(ax, prng, size=(20, 20)):
    """Trace une image avec des valeurs aléatoires et superpose une patch circulaire."""
    values = prng.random_sample(size=size)
    ax.imshow(values, interpolation='none')
    c = plt.Circle((5, 5), radius=5, label='patch')
    ax.add_patch(c)
    ## Supprime les étiquettes d'axe
    ax.set_xticks([])
    ax.set_yticks([])


def plot_histograms(ax, prng, nb_samples=10000):
    """Trace 4 histogrammes et une annotation de texte."""
    params = ((10, 10), (4, 12), (50, 12), (6, 55))
    for a, b in params:
        values = prng.beta(a, b, size=nb_samples)
        ax.hist(values, histtype="stepfilled", bins=30,
                alpha=0.8, density=True)

    ## Ajoute une petite annotation.
    ax.annotate('Annotation', xy=(0.25, 4.25),
                xytext=(0.9, 0.9), textcoords=ax.transAxes,
                va="top", ha="right",
                bbox=dict(boxstyle="round", alpha=0.2),
                arrowprops=dict(
                          arrowstyle="->",
                          connectionstyle="angle,angleA=-95,angleB=35,rad=10"),
                )
    return ax

Définition de la fonction de tracé

Maintenant, vous devez définir la fonction plot_figure() qui configurera et tracera la figure de démonstration avec un style donné. Cette fonction appellera chacune des fonctions de tracé définies dans l'Étape 2.

def plot_figure(style_label=""):
    """Configure et trace la figure de démonstration avec un style donné."""
    ## Utilisez une instance dédiée de RandomState pour tracer les mêmes valeurs "aléatoires"
    ## sur les différentes figures.
    prng = np.random.RandomState(96917002)

    fig, axs = plt.subplots(ncols=6, nrows=1, num=style_label,
                            figsize=(14.8, 2.8), layout='constrained')

    ## Crée un supertitre, dans le même style pour toutes les sous-figures,
    ## sauf celles avec des fonds foncés, qui obtiennent une couleur plus claire :
    background_color = mcolors.rgb_to_hsv(
        mcolors.to_rgb(plt.rcParams['figure.facecolor']))[2]
    if background_color < 0.5:
        title_color = [0.8, 0.8, 1]
    else:
        title_color = np.array([19, 6, 84]) / 256
    fig.suptitle(style_label, x=0.01, ha='left', color=title_color,
                 fontsize=14, fontfamily='DejaVu Sans', fontweight='normal')

    plot_scatter(axs[0], prng)
    plot_image_and_patch(axs[1], prng)
    plot_bar_graphs(axs[2], prng)
    plot_colored_lines(axs[3])
    plot_histograms(axs[4], prng)
    plot_colored_circles(axs[5], prng)

    ## ajoute un séparateur
    rec = Rectangle((1 + 0.025, -2), 0.05, 16,
                    clip_on=False, color='gray')

    axs[4].add_artist(rec)

Tracer la figure de démonstration pour chaque feuille de style

Enfin, vous devez tracer la figure de démonstration pour chaque feuille de style disponible. Vous pouvez le faire en parcourant la liste style_list et en appelant la fonction plot_figure() pour chaque feuille de style.

if __name__ == "__main__":

    ## Configurez une liste de tous les styles disponibles, dans l'ordre alphabétique, mais
    ## les styles `default` et `classic`, qui seront forcés respectivement en
    ## première et deuxième position.
    ## Les styles commençant par un underscore sont destinés à une utilisation interne, telle que les tests
    ## et la galerie de types de tracé. Ils sont exclus ici.
    style_list = ['default', 'classic'] + sorted(
        style for style in plt.style.available
        if style!= 'classic' and not style.startswith('_'))

    ## Tracez une figure de démonstration pour chaque feuille de style disponible.
    for style_label in style_list:
        with plt.rc_context({"figure.max_open_warning": len(style_list)}):
            with plt.style.context(style_label):
                plot_figure(style_label=style_label)

    plt.show()

Sommaire

Dans ce laboratoire, vous avez appris à utiliser les feuilles de style de Matplotlib pour personnaliser l'apparence de vos tracés. Vous avez appris à définir des fonctions de tracé et à les utiliser pour créer une figure de démonstration avec une feuille de style donnée. En suivant les étapes décrites dans ce laboratoire, vous pouvez appliquer les feuilles de style de Matplotlib à vos propres tracés pour créer des visualisations de données ayant l'air professionnel.