Personaliza tus gráficos de Matplotlib con hojas de estilo

Introducción

Matplotlib es una poderosa biblioteca de visualización de datos en Python. Te permite crear una variedad de gráficos, como diagramas de dispersión, histogramas, gráficos de barras y más. El script de referencia de hojas de estilo demuestra las diferentes hojas de estilo disponibles en un conjunto común de gráficos de ejemplo. En este laboratorio, aprenderás a usar las hojas de estilo de Matplotlib para personalizar la apariencia de tus gráficos.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haz 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 tengas que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tienes problemas durante el aprendizaje, no dudes en preguntar a Labby. Proporciona retroalimentación después de la sesión y te resolveremos el problema inmediatamente.

Importar bibliotecas

Antes de comenzar, debes importar las bibliotecas necesarias. En este laboratorio, utilizarás Matplotlib y NumPy.

import matplotlib.pyplot as plt
import numpy as np

Definir las funciones de trazado

A continuación, debes definir las funciones de trazado que se utilizarán para crear los gráficos de ejemplo. En este paso, definirás las siguientes funciones de trazado:

plot_scatter(): crea un diagrama de dispersión
plot_colored_lines(): traza líneas con colores siguiendo el ciclo de colores de estilo
plot_bar_graphs(): crea un gráfico de barras
plot_colored_circles(): traza parches circulares
plot_image_and_patch(): traza una imagen con un parche circular
plot_histograms(): crea histogramas

def plot_scatter(ax, prng, nb_samples=100):
    """Diagrama de dispersión."""
    for mu, sigma, marker in [(-.5, 0.75, 'o'), (0.75, 1.,'s')]:
        x, y = prng.normal(loc=mu, scale=sigma, size=(2, nb_samples))
        ax.plot(x, y, ls='none', marker=marker)
    ax.set_xlabel('Etiqueta de X')
    ax.set_title('Título de los ejes')
    return ax


def plot_colored_lines(ax):
    """Traza líneas con colores siguiendo el ciclo de colores de estilo."""
    t = np.linspace(-10, 10, 100)

    def sigmoid(t, t0):
        return 1 / (1 + np.exp(-(t - t0)))

    nb_colors = len(plt.rcParams['axes.prop_cycle'])
    shifts = np.linspace(-5, 5, nb_colors)
    amplitudes = np.linspace(1, 1.5, nb_colors)
    for t0, a in zip(shifts, amplitudes):
        ax.plot(t, a * sigmoid(t, t0), '-')
    ax.set_xlim(-10, 10)
    return ax


def plot_bar_graphs(ax, prng, min_value=5, max_value=25, nb_samples=5):
    """Traza dos gráficos de barras lado a lado, con letras como etiquetas de marcas de tiempo en x."""
    x = np.arange(nb_samples)
    ya, yb = prng.randint(min_value, max_value, size=(2, nb_samples))
    width = 0.25
    ax.bar(x, ya, width)
    ax.bar(x + width, yb, width, color='C2')
    ax.set_xticks(x + width, labels=['a', 'b', 'c', 'd', 'e'])
    return ax


def plot_colored_circles(ax, prng, nb_samples=15):
    """
    Traza parches circulares.

    NB: dibuja una cantidad fija de muestras, en lugar de utilizar la longitud
    del ciclo de colores, porque diferentes estilos pueden tener diferentes
    números de colores.
    """
    for sty_dict, j in zip(plt.rcParams['axes.prop_cycle'](),
                           range(nb_samples)):
        ax.add_patch(plt.Circle(prng.normal(scale=3, size=2),
                                radius=1.0, color=sty_dict['color']))
    ax.grid(visible=True)

    ## Agrega un título para habilitar la cuadrícula
    plt.title('ax.grid(True)', family='monospace', fontsize='small')

    ax.set_xlim([-4, 8])
    ax.set_ylim([-5, 6])
    ax.set_aspect('equal', adjustable='box')  ## para trazar círculos como círculos
    return ax


def plot_image_and_patch(ax, prng, size=(20, 20)):
    """Traza una imagen con valores aleatorios y superpone un parche circular."""
    values = prng.random_sample(size=size)
    ax.imshow(values, interpolation='none')
    c = plt.Circle((5, 5), radius=5, label='parche')
    ax.add_patch(c)
    ## Elimina las marcas de tiempo
    ax.set_xticks([])
    ax.set_yticks([])


def plot_histograms(ax, prng, nb_samples=10000):
    """Traza 4 histogramas y una anotación de texto."""
    params = ((10, 10), (4, 12), (50, 12), (6, 55))
    for a, b in params:
        values = prng.beta(a, b, size=nb_samples)
        ax.hist(values, histtype="stepfilled", bins=30,
                alpha=0.8, density=True)

    ## Agrega una pequeña anotación.
    ax.annotate('Anotación', xy=(0.25, 4.25),
                xytext=(0.9, 0.9), textcoords=ax.transAxes,
                va="top", ha="right",
                bbox=dict(boxstyle="round", alpha=0.2),
                arrowprops=dict(
                          arrowstyle="->",
                          connectionstyle="angle,angleA=-95,angleB=35,rad=10"),
                )
    return ax

Definir la función de trazado

Ahora, debes definir la función plot_figure() que configurará y trazará la figura de demostración con un estilo dado. Esta función llamará a cada una de las funciones de trazado definidas en el Paso 2.

def plot_figure(style_label=""):
    """Configura y traza la figura de demostración con un estilo dado."""
    ## Utiliza una instancia dedicada de RandomState para dibujar los mismos valores "aleatorios"
    ## en las diferentes figuras.
    prng = np.random.RandomState(96917002)

    fig, axs = plt.subplots(ncols=6, nrows=1, num=style_label,
                            figsize=(14.8, 2.8), layout='constrained')

    ## crea un título principal, en el mismo estilo para todas las subfiguras,
    ## excepto aquellas con fondos oscuros, que reciben un color más claro:
    background_color = mcolors.rgb_to_hsv(
        mcolors.to_rgb(plt.rcParams['figure.facecolor']))[2]
    if background_color < 0.5:
        title_color = [0.8, 0.8, 1]
    else:
        title_color = np.array([19, 6, 84]) / 256
    fig.suptitle(style_label, x=0.01, ha='left', color=title_color,
                 fontsize=14, fontfamily='DejaVu Sans', fontweight='normal')

    plot_scatter(axs[0], prng)
    plot_image_and_patch(axs[1], prng)
    plot_bar_graphs(axs[2], prng)
    plot_colored_lines(axs[3])
    plot_histograms(axs[4], prng)
    plot_colored_circles(axs[5], prng)

    ## agrega un divisor
    rec = Rectangle((1 + 0.025, -2), 0.05, 16,
                    clip_on=False, color='gray')

    axs[4].add_artist(rec)

Trazar la figura de demostración para cada hoja de estilo

Finalmente, debes trazar la figura de demostración para cada hoja de estilo disponible. Puedes hacer esto recorriendo la style_list y llamando a la función plot_figure() para cada hoja de estilo.

if __name__ == "__main__":

    ## Configura una lista de todos los estilos disponibles, en orden alfabético pero
    ## los estilos `default` y `classic`, que se colocarán respectivamente en
    ## la primera y segunda posición.
    ## Los estilos con guiones bajos al principio son para uso interno, como pruebas
    ## y galerías de tipos de trazado. Estos se excluyen aquí.
    style_list = ['default', 'classic'] + sorted(
        style for style in plt.style.available
        if style!= 'classic' and not style.startswith('_'))

    ## Traza una figura de demostración para cada hoja de estilo disponible.
    for style_label in style_list:
        with plt.rc_context({"figure.max_open_warning": len(style_list)}):
            with plt.style.context(style_label):
                plot_figure(style_label=style_label)

    plt.show()

Resumen

En este laboratorio, aprendiste cómo utilizar las hojas de estilo de Matplotlib para personalizar la apariencia de tus gráficos. Aprendiste cómo definir funciones de trazado y utilizarlas para crear una figura de demostración con una hoja de estilo dada. Siguiendo los pasos descritos en este laboratorio, puedes aplicar las hojas de estilo de Matplotlib a tus propios gráficos para crear visualizaciones de datos con aspecto profesional.

Hojas de estilo de Matplotlib