Unidades personalizadas de Matplotlib

Introducción

Matplotlib es una biblioteca de trazado para el lenguaje de programación Python. Proporciona una API orientada a objetos para incrustar trazados en aplicaciones que usan kits de herramientas GUI de propósito general como Tkinter, wxPython, Qt o GTK. Matplotlib permite a los desarrolladores crear una amplia variedad de visualizaciones estáticas, animadas e interactivas en Python.

En este laboratorio, aprenderemos cómo crear unidades personalizadas en Matplotlib y trazar datos usando estas unidades personalizadas.

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 operaciones no puede automatizarse 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.

Importar bibliotecas

En el primer paso, necesitamos importar las bibliotecas necesarias: matplotlib.pyplot, numpy, matplotlib.ticker y matplotlib.units.

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

Crear una clase de unidad personalizada

En este paso, crearemos una clase de unidad personalizada: Foo. Esta clase soportará la conversión y diferentes formatos de marcas de graduación según la "unidad". Aquí, la "unidad" es simplemente un factor de conversión escalar.

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

Crear una clase de conversor

En este paso, crearemos una clase de conversor: FooConverter. Esta clase definirá tres métodos estáticos: axisinfo, convert y default_units.

class FooConverter(units.ConversionInterface):
    @staticmethod
    def axisinfo(unit, axis):
        """Devuelve la información del eje Foo."""
        if unit == 1.0 o 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):
        """
        Convierte *obj* usando *unit*.

        Si *obj* es una secuencia, devuelve la secuencia convertida.
        """
        if np.iterable(obj):
            return [o.value(unit) for o in obj]
        else:
            return obj.value(unit)

    @staticmethod
    def default_units(x, axis):
        """Devuelve la unidad predeterminada para *x* o None."""
        if np.iterable(x):
            for thisx in x:
                return thisx.unit
        else:
            return x.unit

Registrar la clase de unidad personalizada

En este paso, registraremos la clase de unidad personalizada - Foo - con la clase de conversor - FooConverter.

units.registry[Foo] = FooConverter()

Crear puntos de datos

En este paso, crearemos algunos puntos de datos usando la clase de unidad personalizada - Foo.

## create some Foos
x = [Foo(val, 1.0) for val in range(0, 50, 2)]
## and some arbitrary y data
y = [i for i in range(len(x))]

Crear gráficos

En este paso, crearemos dos gráficos: uno usando unidades personalizadas y el otro usando unidades predeterminadas.

fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle("Unidades personalizadas")
fig.subplots_adjust(bottom=0.2)

## graficar especificando unidades
ax2.plot(x, y, 'o', xunits=2.0)
ax2.set_title("xunits = 2.0")
plt.setp(ax2.get_xticklabels(), rotation=30, ha='right')

## graficar sin especificar unidades; usará la rama None para axisinfo
ax1.plot(x, y)  ## usa unidades predeterminadas
ax1.set_title('unidades predeterminadas')
plt.setp(ax1.get_xticklabels(), rotation=30, ha='right')

plt.show()

Ejecutar el código

En el último paso, ejecuta el código para crear los gráficos con unidades personalizadas.

Resumen

En este laboratorio, aprendimos cómo crear unidades personalizadas en Matplotlib usando una clase de unidad personalizada y una clase de conversor. Luego creamos dos gráficos: uno usando unidades personalizadas y el otro usando unidades predeterminadas, para demostrar el uso de estas unidades personalizadas. Las unidades personalizadas pueden ser útiles cuando se tratan datos complejos que requieren una escala personalizada o un formato de marcas de graduación personalizado.