Créez des graphiques à boîtes ruban incroyables avec Matplotlib

Introduction

Matplotlib est une bibliothèque populaire de visualisation de données pour Python. Ce tutoriel vous guidera dans la création d'un graphique en boîte ruban, une manière unique de visualiser des données. Un graphique en boîte ruban est un graphique en barres empilées où chaque barre est "en forme de ruban" et a un schéma de couleurs gradué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 à Jupyter Notebook pour la pratique.

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

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 et chargement des données

Dans cette étape, nous allons importer les bibliothèques nécessaires et charger les données.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cbook
from matplotlib import colors as mcolors
from matplotlib.image import AxesImage
from matplotlib.transforms import Bbox, BboxTransformTo, TransformedBbox

Création de la classe RibbonBox

Dans cette étape, nous allons créer la classe RibbonBox qui sera utilisée pour créer les couleurs graduées des boîtes ruban.

class RibbonBox:
    ## Chargez l'image de la boîte ruban
    original_image = plt.imread(cbook.get_sample_data("Minduka_Present_Blue_Pack.png"))
    cut_location = 70
    b_and_h = original_image[:, :, 2:3]
    color = original_image[:, :, 2:3] - original_image[:, :, 0:1]
    alpha = original_image[:, :, 3:4]
    nx = original_image.shape[1]

    def __init__(self, color):
        rgb = mcolors.to_rgb(color)
        self.im = np.dstack([self.b_and_h - self.color * (1 - np.array(rgb)), self.alpha])

    def get_stretched_image(self, stretch_factor):
        stretch_factor = max(stretch_factor, 1)
        ny, nx, nch = self.im.shape
        ny2 = int(ny*stretch_factor)
        return np.vstack([self.im[:self.cut_location],
                          np.broadcast_to(self.im[self.cut_location], (ny2 - ny, nx, nch)),
                          self.im[self.cut_location:]])

Création de la classe RibbonBoxImage

Dans cette étape, nous allons créer la classe RibbonBoxImage qui sera utilisée pour créer les boîtes ruban réelles.

class RibbonBoxImage(AxesImage):
    zorder = 1

    def __init__(self, ax, bbox, color, *, extent=(0, 1, 0, 1), **kwargs):
        super().__init__(ax, extent=extent, **kwargs)
        self._bbox = bbox
        self._ribbonbox = RibbonBox(color)
        self.set_transform(BboxTransformTo(bbox))

    def draw(self, renderer, *args, **kwargs):
        stretch_factor = self._bbox.height / self._bbox.width

        ny = int(stretch_factor*self._ribbonbox.nx)
        if self.get_array() is None or self.get_array().shape[0]!= ny:
            arr = self._ribbonbox.get_stretched_image(stretch_factor)
            self.set_array(arr)

        super().draw(renderer, *args, **kwargs)

Création du graphique

Dans cette étape, nous allons créer le graphique réel en utilisant la classe RibbonBoxImage pour créer les boîtes ruban.

def main():
    fig, ax = plt.subplots()

    years = np.arange(2004, 2009)
    heights = [7900, 8100, 7900, 6900, 2800]
    box_colors = [(0.8, 0.2, 0.2),
                  (0.2, 0.8, 0.2),
                  (0.2, 0.2, 0.8),
                  (0.7, 0.5, 0.8),
                  (0.3, 0.8, 0.7)]

    for year, h, bc in zip(years, heights, box_colors):
        bbox0 = Bbox.from_extents(year - 0.4, 0., year + 0.4, h)
        bbox = TransformedBbox(bbox0, ax.transData)
        ax.add_artist(RibbonBoxImage(ax, bbox, bc, interpolation="bicubic"))
        ax.annotate(str(h), (year, h), va="bottom", ha="center")

    ax.set_xlim(years[0] - 0.5, years[-1] + 0.5)
    ax.set_ylim(0, 10000)

    ## Crée un gradient d'arrière-plan
    background_gradient = np.zeros((2, 2, 4))
    background_gradient[:, :, :3] = [1, 1, 0]
    background_gradient[:, :, 3] = [[0.1, 0.3], [0.3, 0.5]]
    ax.imshow(background_gradient, interpolation="bicubic", zorder=0.1,
              extent=(0, 1, 0, 1), transform=ax.transAxes, aspect="auto")

    plt.show()

main()

Comprendre le graphique

Dans cette étape, nous allons discuter du graphique que nous avons créé. Le graphique est composé de boîtes ruban empilées les unes sur les autres pour former un graphique en barres. La hauteur de chaque boîte ruban correspond à une valeur dans l'ensemble de données. Les boîtes ruban ont un schéma de couleurs graduées qui les rend visuellement attrayantes.

Sommaire

Dans ce tutoriel, nous avons appris à créer un graphique à boîtes ruban à l'aide de Matplotlib. Nous avons créé les classes RibbonBox et RibbonBoxImage pour créer respectivement les couleurs graduées et les boîtes ruban réelles. Nous avons ensuite utilisé ces classes pour créer le graphique, qui est composé de boîtes ruban empilées les unes sur les autres pour former un graphique en barres.

Matplotlib Boîte Ruban