Visualización de datos

Importar librerías

import matplotlib.pyplot as plt
import numpy as np

Anatomía de una figura en Matplotlib

Matplotlib genera sus datos en Figures (es decir, ventanas o “lienzos” en blanco), cada una de las cuales puede contener uno o más Axes (es decir, ejes de coordenadas xy, o theta-r en una gráfica polar, o xyz en un gráfico 3D, etc.).

Figura (figure)

Es todo el conjunto (ejes, títulos, leyendas, lienzo, etc.). Una figura puede contener cualquier número de ejes, pero normalmente tendrá al menos uno.

Ejes (axes)

Es el gráfico propiamente dicho, es decir, la región de la imagen con datos. Una figura determinada puede contener muchos ejes, pero un eje determinado solo puede estar en una figura.

Los ejes, a su vez, contienen dos (o tres en el caso de 3D) objetos Axis (en Matplotlib, Axes y Axis hacen referencia a objetos distintos) que se encargan de los límites de datos (los límites de datos también se pueden controlar mediante los métodos axes.Axes.set_xlim() y axes.Axes.set_ylim()).

Cada eje, además, tiene un título (establecido mediante set_title()), una etiqueta x (establecida mediante set_xlabel()) y una etiqueta y (configurada mediante set_ylabel()).

Ejes (axis)

Son objetos parecidos a una recta numérica que se encargan de establecer los límites del gráfico y generar los ticks (las marcas en el eje) y ticklabels (cadenas de texto que hacen referencia a cada tick).

Objetos artist

Básicamente todo lo que se puede ver en la figura es un artist (incluso los objetos de tipo Figure, Axes y Axis). Cuando se renderiza la figura, todos los artists se dibujan en el lienzo. La mayoría de los artists están atados a ejes; un artist no puede ser compartido por varios ejes, ni moverse de uno a otro.

La interfaz orientada a objetos y la interfaz pyplot

Hay esencialmente dos formas de usar Matplotlib:

• Creando explícitamente figuras y ejes, y llamando a métodos sobre ellos (el “estilo orientado a objetos (OO)”).
• Confiando en pyplot para crear y administrar automáticamente las figuras y los ejes, y utilizando las funciones de pyplot para trazar.

Cualquiera de ellos es perfectamente válido, aunque es preferible elegir uno de ellos y ceñirse a él, en lugar de mezclarlos en un mismo script o cuaderno de Jupyter. En general, se recomienda restringir pyplot al trazado interactivo (por ejemplo, en un cuaderno de Jupyter) y preferir el estilo OO para el trazado no interactivo (en funciones y scripts que están destinados a ser reutilizados como parte de un proyecto más grande).

Estilo orientado a objetos (OO)

x = np.linspace(0, 2, 100)
x

array([0.        , 0.02020202, 0.04040404, 0.06060606, 0.08080808,
       0.1010101 , 0.12121212, 0.14141414, 0.16161616, 0.18181818,
       0.2020202 , 0.22222222, 0.24242424, 0.26262626, 0.28282828,
       0.3030303 , 0.32323232, 0.34343434, 0.36363636, 0.38383838,
       0.4040404 , 0.42424242, 0.44444444, 0.46464646, 0.48484848,
       0.50505051, 0.52525253, 0.54545455, 0.56565657, 0.58585859,
       0.60606061, 0.62626263, 0.64646465, 0.66666667, 0.68686869,
       0.70707071, 0.72727273, 0.74747475, 0.76767677, 0.78787879,
       0.80808081, 0.82828283, 0.84848485, 0.86868687, 0.88888889,
       0.90909091, 0.92929293, 0.94949495, 0.96969697, 0.98989899,
       1.01010101, 1.03030303, 1.05050505, 1.07070707, 1.09090909,
       1.11111111, 1.13131313, 1.15151515, 1.17171717, 1.19191919,
       1.21212121, 1.23232323, 1.25252525, 1.27272727, 1.29292929,
       1.31313131, 1.33333333, 1.35353535, 1.37373737, 1.39393939,
       1.41414141, 1.43434343, 1.45454545, 1.47474747, 1.49494949,
       1.51515152, 1.53535354, 1.55555556, 1.57575758, 1.5959596 ,
       1.61616162, 1.63636364, 1.65656566, 1.67676768, 1.6969697 ,
       1.71717172, 1.73737374, 1.75757576, 1.77777778, 1.7979798 ,
       1.81818182, 1.83838384, 1.85858586, 1.87878788, 1.8989899 ,
       1.91919192, 1.93939394, 1.95959596, 1.97979798, 2.        ])

# Una figura vacía sin ejes
fig = plt.figure(figsize= (12,16))

# Una figura con un solo eje
fig, ax = plt.subplots()
ax.plot(x, x, label = "lineal")
ax.plot(x, x**2, label = "cuadrático")
ax.plot(x, x**3, label = "cúbico")
ax.set_xlabel("Etiqueta eje X")
ax.set_ylabel("Etiqueta eje Y")
ax.set_title("Gráfico de ejemplo")
ax.legend()

<matplotlib.legend.Legend at 0xaa97f70>

# Una figura con una cuadrícula de 2x2 ejes (4 ejes)
_, axes = plt.subplots(2,2)

Estilo pyplot

x = np.linspace(0, 2, 100)

plt.plot(x, x, label = "lineal")
plt.plot(x, x**2, label = "cuadrático")
plt.plot(x, x**3, label = "cúbico")
plt.xlabel("Etiqueta eje X")
plt.ylabel("Etiqueta eje Y")
plt.title("Gráfico de ejemplo")
plt.legend()

<matplotlib.legend.Legend at 0xa86de50>

Plantilla de función

Es habitual utilizar los mismos gráficos una y otra vez, pero con diferentes conjuntos de datos, lo que lleva a la necesidad de escribir funciones especializadas que permitan reutilizar código y ahorren trabajo.

def plot_function(ax, data1, data2, param_dict):
    
    """
    Una función de ayuda para hacer un gráfico con matplotlib.pyplot
    
    Parámetros
    ------------------------
    ax: Axes
        Los ejes sobre los cuales dibujar
    
    data1: array
        Un primer vector de datos (x)
        
    data2: array
        Un segundo vector de datos (y)
    
    param_dict: dict
        Diccionario de parámetros para pasarle a ax.plot
        
    Devuelve
    -------------------------
    out: list
        Lista de objetos de tipo "artist" añadidos
        
    """
    
    out = ax.plot(data1, data2, **param_dict)
    return out

fig, ax = plt.subplots(1,1)
data_a = [1,2,3,4]
data_b = [2,3,4,5]
par_dict = {"marker": "o", "color": "green", "markersize": 12}

plot_function(ax = ax, data1 = data_a, data2 = data_b, param_dict = par_dict)

[<matplotlib.lines.Line2D at 0x97f5d60>]

fig, ax = plt.subplots(1,1)
par_dict = {"marker": "o", "color": "green", "markersize": 12}
data_c = [10,20,30,40]
data_d = [100,200,300,400]
plot_function(ax = ax, data1 = data_c, data2 = data_d, param_dict = par_dict)

[<matplotlib.lines.Line2D at 0xa7b0eb0>]

fig, (ax1, ax2) = plt.subplots(1, 2)
plot_function(ax = ax1, data1 = data_a, data2 = data_b, param_dict = {"marker": "x", "color": "red", "markersize": 6})
plot_function(ax = ax2, data1 = data_c, data2 = data_d, param_dict = {"marker": "o", "color": "green", "markersize": 12})

[<matplotlib.lines.Line2D at 0xa372c70>]