Diagrama de caja con listón de Matplotlib

Introducción

Matplotlib es una popular biblioteca de visualización de datos para Python. En este tutorial, lo guiaremos a través de la creación de un diagrama de caja con listón, una forma única de visualizar datos. Un diagrama de caja con listón es un diagrama de barras apiladas donde cada barra es "parecida a un listón" y tiene un esquema de colores de degradado.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Importando bibliotecas y cargando datos

En este paso, importaremos las bibliotecas necesarias y cargaremos los datos.

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

Creando la clase RibbonBox

En este paso, crearemos la clase RibbonBox que se utilizará para crear los colores de degradado para las cajas con listón.

class RibbonBox:
    ## Carga la imagen de la caja con listón
    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:]])

Creando la clase RibbonBoxImage

En este paso, crearemos la clase RibbonBoxImage que se utilizará para crear las cajas con listón reales.

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)

Creando el diagrama

En este paso, crearemos el diagrama real utilizando la clase RibbonBoxImage para crear las cajas con listón.

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)

    ## Crea un degradado de fondo
    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()

Comprendiendo el diagrama

En este paso, discutiremos el diagrama que hemos creado. El diagrama consta de cajas con listón apiladas una encima de la otra para formar un diagrama de barras. La altura de cada caja con listón corresponde a un valor en el conjunto de datos. Las cajas con listón tienen un esquema de colores de degradado que las hace visualmente atractivas.

Resumen

En este tutorial, aprendimos cómo crear un diagrama de cajas con listón utilizando Matplotlib. Creamos las clases RibbonBox y RibbonBoxImage para crear los colores de degradado y las cajas con listón reales, respectivamente. Luego utilizamos estas clases para crear el diagrama, que consta de cajas con listón apiladas una encima de la otra para formar un diagrama de barras.