Matplotlib Fill Between

Introduction

Matplotlib est une bibliothèque de visualisation de données en langage de programmation Python. Elle est utilisée pour créer des visualisations statiques, animées et interactives en Python. Dans ce laboratoire, vous allez apprendre à utiliser la fonction fill_between de Matplotlib pour remplir la zone entre deux lignes.

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 de notes 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.

Skills Graph

Utilisation de base

La fonction fill_between peut être utilisée pour remplir la zone entre deux lignes. Les paramètres y1 et y2 peuvent être des scalaires, indiquant une limite horizontale aux valeurs de y données. Si seul y1 est donné, y2 est égal à 0 par défaut.

x = np.arange(0.0, 2, 0.01)
y1 = np.sin(2 * np.pi * x)
y2 = 0.8 * np.sin(4 * np.pi * x)

fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(6, 6))

ax1.fill_between(x, y1)
ax1.set_title('remplissage entre y1 et 0')

ax2.fill_between(x, y1, 1)
ax2.set_title('remplissage entre y1 et 1')

ax3.fill_between(x, y1, y2)
ax3.set_title('remplissage entre y1 et y2')
ax3.set_xlabel('x')
fig.tight_layout()

Bandes de confiance

Une application courante de fill_between est l'indication des bandes de confiance. fill_between utilise les couleurs du cycle de couleurs comme couleur de remplissage. Il est donc souvent une bonne pratique d'alléger la couleur en rendant la zone semi-transparente à l'aide de alpha.

N = 21
x = np.linspace(0, 10, 11)
y = [3.9, 4.4, 10.8, 10.3, 11.2, 13.1, 14.1,  9.9, 13.9, 15.1, 12.5]

## ajuster une courbe linéaire et estimer ses valeurs de y et leur erreur.
a, b = np.polyfit(x, y, deg=1)
y_est = a * x + b
y_err = x.std() * np.sqrt(1/len(x) +
                          (x - x.mean())**2 / np.sum((x - x.mean())**2))

fig, ax = plt.subplots()
ax.plot(x, y_est, '-')
ax.fill_between(x, y_est - y_err, y_est + y_err, alpha=0.2)
ax.plot(x, y, 'o', color='tab:brown')

Remplissage sélectif de régions horizontales

Le paramètre where permet de spécifier les plages d'abscisses à remplir. C'est un tableau booléen de même taille que x. Seules les plages d'abscisses de séquences consécutives de True sont remplies. En conséquence, la plage entre les valeurs True et False voisines n'est jamais remplie. Il est donc recommandé de définir interpolate=True à moins que la distance en abscisses des points de données ne soit suffisamment fine pour que l'effet ci-dessus ne soit pas sensible.

x = np.array([0, 1, 2, 3])
y1 = np.array([0.8, 0.8, 0.2, 0.2])
y2 = np.array([0, 0, 1, 1])

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.set_title('interpolation=False')
ax1.plot(x, y1, 'o--')
ax1.plot(x, y2, 'o--')
ax1.fill_between(x, y1, y2, where=(y1 > y2), color='C0', alpha=0.3)
ax1.fill_between(x, y1, y2, where=(y1 < y2), color='C1', alpha=0.3)

ax2.set_title('interpolation=True')
ax2.plot(x, y1, 'o--')
ax2.plot(x, y2, 'o--')
ax2.fill_between(x, y1, y2, where=(y1 > y2), color='C0', alpha=0.3,
                 interpolate=True)
ax2.fill_between(x, y1, y2, where=(y1 <= y2), color='C1', alpha=0.3,
                 interpolate=True)
fig.tight_layout()

Marquage sélectif de régions horizontales sur toute la zone d'un axe

Le même mécanisme de sélection peut être appliqué pour remplir la hauteur verticale totale de l'axe. Pour être indépendant des limites en y, nous ajoutons une transformation qui interprète les valeurs d'abscisses dans les coordonnées des données et les valeurs d'ordonnées dans les coordonnées de l'axe. L'exemple suivant marque les régions dans lesquelles les données en y sont au-dessus d'un seuil donné.

fig, ax = plt.subplots()
x = np.arange(0, 4 * np.pi, 0.01)
y = np.sin(x)
ax.plot(x, y, color='black')

threshold = 0.75
ax.axhline(threshold, color='green', lw=2, alpha=0.7)
ax.fill_between(x, 0, 1, where=y > threshold,
                color='green', alpha=0.5, transform=ax.get_xaxis_transform())

Sommaire

Dans ce laboratoire, vous avez appris à utiliser la fonction fill_between de Matplotlib pour remplir la zone entre deux lignes. Vous avez également appris à remplir sélectivement des régions horizontales et à marquer des régions horizontales sur toute la zone d'un axe.