Positionneurs de graduations Matplotlib

Introduction

Dans ce tutoriel, nous allons apprendre à définir la position des graduations dans un graphique matplotlib en utilisant des positionneurs de graduations. Les positionneurs de graduations aident à rendre les graphiques plus lisibles en définissant la position des graduations sur les axes x et y. Nous allons aborder différents types de positionneurs de graduations et comment les implémenter dans un graphique matplotlib.

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 la pratique.

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églerons rapidement le problème pour vous.

Importation des bibliothèques

La première étape consiste à importer les bibliothèques nécessaires. Nous allons utiliser matplotlib.pyplot et matplotlib.ticker.

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np

Préparation du graphique

Ensuite, nous allons préparer le graphique en créant une figure et un tableau de sous-graphiques. Nous définirons également une fonction setup qui définit les paramètres communs pour les axes dans l'exemple.

fig, axs = plt.subplots(8, 1, figsize=(8, 6))

def setup(ax, title):
    """Définir les paramètres communs pour les Axes dans l'exemple."""
    ## ne montrer que la ligne inférieure de l'épine
    ax.yaxis.set_major_locator(ticker.NullLocator())
    ax.spines[['left', 'right', 'top']].set_visible(False)

    ax.xaxis.set_ticks_position('bottom')
    ax.tick_params(which='major', width=1.00, length=5)
    ax.tick_params(which='minor', width=0.75, length=2.5)
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 1)
    ax.text(0.0, 0.2, title, transform=ax.transAxes,
            fontsize=14, fontname='Monospace', color='tab:blue')

Définition du positionneur nul

Le positionneur nul est un positionneur qui ne place pas de graduation sur l'axe. Nous pouvons définir le positionneur nul en utilisant ticker.NullLocator().

setup(axs[0], title="NullLocator()")
axs[0].xaxis.set_major_locator(ticker.NullLocator())
axs[0].xaxis.set_minor_locator(ticker.NullLocator())

Définition du positionneur multiple

Le positionneur multiple est un positionneur qui place les graduations à des intervalles réguliers. Nous pouvons définir le positionneur multiple en utilisant ticker.MultipleLocator().

setup(axs[1], title="MultipleLocator(0.5, offset=0.2)")
axs[1].xaxis.set_major_locator(ticker.MultipleLocator(0.5, offset=0.2))
axs[1].xaxis.set_minor_locator(ticker.MultipleLocator(0.1))

Définition du positionneur fixe

Le positionneur fixe est un positionneur qui place les graduations à des emplacements fixes. Nous pouvons définir le positionneur fixe en utilisant ticker.FixedLocator().

setup(axs[2], title="FixedLocator([0, 1, 5])")
axs[2].xaxis.set_major_locator(ticker.FixedLocator([0, 1, 5]))
axs[2].xaxis.set_minor_locator(ticker.FixedLocator(np.linspace(0.2, 0.8, 4)))

Définition du positionneur linéaire

Le positionneur linéaire est un positionneur qui place les graduations à des intervalles réguliers sur une échelle linéaire. Nous pouvons définir le positionneur linéaire en utilisant ticker.LinearLocator().

setup(axs[3], title="LinearLocator(numticks=3)")
axs[3].xaxis.set_major_locator(ticker.LinearLocator(3))
axs[3].xaxis.set_minor_locator(ticker.LinearLocator(31))

Définition du positionneur d'index

Le positionneur d'index est un positionneur qui place les graduations à des intervalles réguliers sur une échelle d'index. Nous pouvons définir le positionneur d'index en utilisant ticker.IndexLocator().

setup(axs[4], title="IndexLocator(base=0.5, offset=0.25)")
axs[4].plot([0]*5, color='white')
axs[4].xaxis.set_major_locator(ticker.IndexLocator(base=0.5, offset=0.25))

Définition du positionneur automatique

Le positionneur automatique est un positionneur qui place automatiquement les graduations à des intervalles réguliers. Nous pouvons définir le positionneur automatique en utilisant ticker.AutoLocator().

setup(axs[5], title="AutoLocator()")
axs[5].xaxis.set_major_locator(ticker.AutoLocator())
axs[5].xaxis.set_minor_locator(ticker.AutoMinorLocator())

Définition du positionneur MaxN

Le positionneur MaxN est un positionneur qui place un nombre maximum de graduations sur l'axe. Nous pouvons définir le positionneur MaxN en utilisant ticker.MaxNLocator().

setup(axs[6], title="MaxNLocator(n=4)")
axs[6].xaxis.set_major_locator(ticker.MaxNLocator(4))
axs[6].xaxis.set_minor_locator(ticker.MaxNLocator(40))

Définition du positionneur logarithmique

Le positionneur logarithmique est un positionneur qui place les graduations à des intervalles réguliers sur une échelle logarithmique. Nous pouvons définir le positionneur logarithmique en utilisant ticker.LogLocator().

setup(axs[7], title="LogLocator(base=10, numticks=15)")
axs[7].set_xlim(10**3, 10**10)
axs[7].set_xscale('log')
axs[7].xaxis.set_major_locator(ticker.LogLocator(base=10, numticks=15))

Affichage du graphique

Enfin, nous pouvons afficher le graphique en utilisant plt.show().

plt.tight_layout()
plt.show()

Sommaire

Dans ce tutoriel, nous avons appris à définir la position des graduations dans un graphique matplotlib en utilisant des positionneurs de graduations. Nous avons abordé différents types de positionneurs de graduations et la manière de les implémenter dans un graphique matplotlib. Cela peut aider à rendre les graphiques plus lisibles et informatifs.