Unités personnalisées de Matplotlib

Introduction

Matplotlib est une bibliothèque de tracé pour le langage de programmation Python. Elle fournit une API orientée objet pour intégrer des graphiques dans des applications utilisant des kits de bibliothèques GUI de type général tels que Tkinter, wxPython, Qt ou GTK. Matplotlib permet aux développeurs de créer une large gamme de visualisations statiques, animées et interactives en Python.

Dans ce laboratoire, nous allons apprendre à créer des unités personnalisées dans Matplotlib et à tracer des données à l'aide de ces unités personnalisées.

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

Importation des bibliothèques

Dans la première étape, nous devons importer les bibliothèques requises - matplotlib.pyplot, numpy, matplotlib.ticker et matplotlib.units.

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

Créer une classe d'unité personnalisée

Dans cette étape, nous allons créer une classe d'unité personnalisée - Foo. Cette classe prendra en charge la conversion et différents formats d'étiquetage en fonction de l'"unité". Ici, l'"unité" est simplement un facteur de conversion scalaire.

class Foo:
    def __init__(self, val, unit=1.0):
        self.unit = unit
        self._val = val * unit

    def value(self, unit):
        if unit is None:
            unit = self.unit
        return self._val / unit

Créer une classe de convertisseur

Dans cette étape, nous allons créer une classe de convertisseur - FooConverter. Cette classe définira trois méthodes statiques - axisinfo, convert et default_units.

class FooConverter(units.ConversionInterface):
    @staticmethod
    def axisinfo(unit, axis):
        """Retourne les informations sur l'axe Foo."""
        if unit == 1.0 ou unit == 2.0:
            return units.AxisInfo(
                majloc=ticker.IndexLocator(8, 0),
                majfmt=ticker.FormatStrFormatter("VAL: %s"),
                label='foo',
                )

        else:
            return None

    @staticmethod
    def convert(obj, unit, axis):
        """
        Convertit *obj* à l'aide de *unit*.

        Si *obj* est une séquence, retourne la séquence convertie.
        """
        if np.iterable(obj):
            return [o.value(unit) for o in obj]
        else:
            return obj.value(unit)

    @staticmethod
    def default_units(x, axis):
        """Retourne l'unité par défaut pour *x* ou None."""
        if np.iterable(x):
            for thisx in x:
                return thisx.unit
        else:
            return x.unit

Enregistrer la classe d'unité personnalisée

Dans cette étape, nous allons enregistrer la classe d'unité personnalisée - Foo - avec la classe de convertisseur - FooConverter.

units.registry[Foo] = FooConverter()

Créer des points de données

Dans cette étape, nous allons créer quelques points de données à l'aide de la classe d'unité personnalisée - Foo.

## créer quelques Foos
x = [Foo(val, 1.0) for val in range(0, 50, 2)]
## et quelques données y arbitraires
y = [i for i in range(len(x))]

Créer des graphiques

Dans cette étape, nous allons créer deux graphiques - l'un utilisant des unités personnalisées et l'autre utilisant les unités par défaut.

fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle("Unités personnalisées")
fig.subplots_adjust(bottom=0.2)

## tracer en spécifiant les unités
ax2.plot(x, y, 'o', xunits=2.0)
ax2.set_title("xunits = 2.0")
plt.setp(ax2.get_xticklabels(), rotation=30, ha='right')

## tracer sans spécifier les unités ; utilisera la branche None pour axisinfo
ax1.plot(x, y)  ## utilise les unités par défaut
ax1.set_title('Unités par défaut')
plt.setp(ax1.get_xticklabels(), rotation=30, ha='right')

plt.show()

Exécuter le code

Dans la dernière étape, exécutez le code pour créer les graphiques avec les unités personnalisées.

Sommaire

Dans ce laboratoire, nous avons appris à créer des unités personnalisées dans Matplotlib à l'aide d'une classe d'unité personnalisée et d'une classe de convertisseur. Nous avons ensuite créé deux graphiques - l'un utilisant des unités personnalisées et l'autre utilisant les unités par défaut - pour démontrer l'utilisation de ces unités personnalisées. Les unités personnalisées peuvent être utiles lorsqu'il s'agit de traiter des données complexes qui nécessitent une mise à l'échelle personnalisée ou un formatage d'étiquette d'échelle.