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 dispersionplot_colored_lines(): trace des lignes avec des couleurs suivant le cycle de couleurs du styleplot_bar_graphs(): crée un diagramme en barresplot_colored_circles(): trace des patches circulairesplot_image_and_patch(): trace une image avec une patch circulaireplot_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.