guía de inicio rápido

Este tutorial cubre algunos patrones de uso básicos y mejores prácticas para ayudarlo a comenzar con Matplotlib.

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

Un ejemplo sencillo

Matplotlib grafica sus datos en Figures (por ejemplo, ventanas, widgets de Jupyter, etc.), cada uno de los cuales puede contener uno o más Axes, un área donde los puntos se pueden especificar en términos de coordenadas xy (o theta-r en un gráfico polar, xyz en un gráfico 3D, etc.). La forma más sencilla de crear una Figura con Ejes es usando pyplot.subplots. Luego podemos usar Axes.plotpara dibujar algunos datos en los ejes:

fig, ax = plt.subplots()  # Create a figure containing a single axes.
ax.plot([1, 2, 3, 4], [1, 4, 2, 3]);  # Plot some data on the axes.

[<matplotlib.lines.Line2D object at 0x7f2cdf586e60>]

Partes de una figura

Estos son los componentes de una figura de Matplotlib.

Figure

Toda la figura . La figura realiza un seguimiento de todos los niños Axes, un grupo de artistas "especiales" (títulos, leyendas de figuras, barras de colores, etc.) e incluso subfiguras anidadas.

La forma más fácil de crear una nueva Figura es con pyplot:

fig = plt.figure()  # an empty figure with no Axes
fig, ax = plt.subplots()  # a figure with a single Axes
fig, axs = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes

A menudo es conveniente crear los Ejes junto con la Figura, pero también puede agregar Ejes manualmente más adelante. Tenga en cuenta que muchos backends de Matplotlib admiten el zoom y la panorámica en las ventanas de figuras.

Axes

Un Axes es un artista adjunto a una figura que contiene una región para trazar datos y, por lo general, incluye dos (o tres en el caso de 3D) Axisobjetos (tenga en cuenta la diferencia entre Axes y Axis ) que proporcionan marcas y etiquetas de marcas para proporcionar escalas para los datos en los Ejes. Cada uno Axestambién tiene un título (establecido a través set_title()de ), una etiqueta x (establecida a través set_xlabel()de ) y una etiqueta y establecida a través de set_ylabel()).

La Axesclase y sus funciones miembro son el punto de entrada principal para trabajar con la interfaz OOP y tienen la mayoría de los métodos de trazado definidos en ellas (p. ej ax.plot(). , que se muestra arriba, usa el plotmétodo)

Axis

Estos objetos establecen la escala y los límites y generan marcas (las marcas en el eje) y etiquetas de marcas (cadenas que etiquetan las marcas). La ubicación de las marcas está determinada por un Locatorobjeto y las cadenas de etiquetas de marcas tienen el formato de un archivo Formatter. La combinación de la correcta Locatory Formatterda un control muy fino sobre las ubicaciones y etiquetas de marca.

Artist

Básicamente, todo lo visible en la Figura es un Artista (incluso Figure, Axesy Axisobjetos). Esto incluye Textobjetos, Line2Dobjetos, collectionsobjetos, Patch objetos, etc. Cuando se renderiza la figura, todos los artistas se dibujan en el lienzo . La mayoría de los artistas están atados a un eje; dicho artista no puede ser compartido por múltiples ejes, ni movido de uno a otro.

Tipos de entradas para funciones de trazado

Las funciones de trazado esperan numpy.arrayo numpy.ma.masked_arraycomo entrada, u objetos que se pueden pasar a numpy.asarray. Las clases que son similares a las matrices ('parecidas a una matriz'), como pandas los objetos de datos, numpy.matrixpueden no funcionar según lo previsto. La convención común es convertirlos en numpy.arrayobjetos antes de trazarlos. Por ejemplo, para convertir unnumpy.matrix

b = np.matrix([[1, 2], [3, 4]])
b_asarray = np.asarray(b)

La mayoría de los métodos también analizarán un objeto direccionable como dict , a numpy.recarrayo a pandas.DataFrame. Matplotlib le permite proporcionar el dataargumento de la palabra clave y generar gráficos pasando las cadenas correspondientes a las variables x e y .

np.random.seed(19680801)  # seed the random number generator.
data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.scatter('a', 'b', c='c', s='d', data=data)
ax.set_xlabel('entry a')
ax.set_ylabel('entry b');

Text(36.334, 0.5, 'entry b')

Estilos de codificación

Las interfaces explícitas e implícitas

Como se señaló anteriormente, hay esencialmente dos formas de usar Matplotlib:

• Cree explícitamente figuras y ejes, y llame a métodos en ellos (el "estilo orientado a objetos (OO)").

• Confíe en pyplot para crear y administrar implícitamente las figuras y los ejes, y use las funciones de pyplot para trazar.

Consulte Interfaces de aplicación (API) de Matplotlib para obtener una explicación de las compensaciones entre las interfaces implícitas y explícitas.

Entonces uno puede usar el estilo OO

x = np.linspace(0, 2, 100)  # Sample data.

# Note that even in the OO-style, we use `.pyplot.figure` to create the Figure.
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.plot(x, x, label='linear')  # Plot some data on the axes.
ax.plot(x, x**2, label='quadratic')  # Plot more data on the axes...
ax.plot(x, x**3, label='cubic')  # ... and some more.
ax.set_xlabel('x label')  # Add an x-label to the axes.
ax.set_ylabel('y label')  # Add a y-label to the axes.
ax.set_title("Simple Plot")  # Add a title to the axes.
ax.legend();  # Add a legend.

<matplotlib.legend.Legend object at 0x7f2cdf587f70>

o el estilo pyplot:

x = np.linspace(0, 2, 100)  # Sample data.

plt.figure(figsize=(5, 2.7), layout='constrained')
plt.plot(x, x, label='linear')  # Plot some data on the (implicit) axes.
plt.plot(x, x**2, label='quadratic')  # etc.
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend();

<matplotlib.legend.Legend object at 0x7f2cfa992cb0>

(Además, existe un tercer enfoque, para el caso de incrustar Matplotlib en una aplicación GUI, que elimina completamente pyplot, incluso para la creación de figuras. Consulte la sección correspondiente en la galería para obtener más información: Incrustación de Matplotlib en interfaces gráficas de usuario ).

La documentación y los ejemplos de Matplotlib usan los estilos OO y pyplot. En general, sugerimos usar el estilo OO, particularmente para tramas complicadas y funciones y scripts que están destinados a ser reutilizados como parte de un proyecto más grande. Sin embargo, el estilo pyplot puede ser muy conveniente para un trabajo interactivo rápido.

Nota

Puede encontrar ejemplos más antiguos que usan la pylabinterfaz, a través de . Este enfoque está fuertemente desaprobado.from pylab import *

Hacer funciones auxiliares

Si necesita hacer los mismos gráficos una y otra vez con diferentes conjuntos de datos, o desea envolver fácilmente los métodos de Matplotlib, use la función de firma recomendada a continuación.

def my_plotter(ax, data1, data2, param_dict):
    """
    A helper function to make a graph.
    """
    out = ax.plot(data1, data2, **param_dict)
    return out

que luego usaría dos veces para completar dos subparcelas:

data1, data2, data3, data4 = np.random.randn(4, 100)  # make 4 random data sets
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(5, 2.7))
my_plotter(ax1, data1, data2, {'marker': 'x'})
my_plotter(ax2, data3, data4, {'marker': 'o'});

[<matplotlib.lines.Line2D object at 0x7f2cddab7c10>]

Tenga en cuenta que si desea instalarlos como un paquete de python, o cualquier otra personalización, puede usar una de las muchas plantillas en la web; Matplotlib tiene uno en mpl-cookiecutter

Artistas de estilismo

La mayoría de los métodos de trazado tienen opciones de estilo para los Artistas, a las que se puede acceder cuando se llama a un método de trazado o desde un "establecedor" en el Artista. En el siguiente diagrama, configuramos manualmente el color , el ancho de línea y el estilo de línea de los Artistas creados por plot, y configuramos el estilo de línea de la segunda línea después del hecho con set_linestyle.

fig, ax = plt.subplots(figsize=(5, 2.7))
x = np.arange(len(data1))
ax.plot(x, np.cumsum(data1), color='blue', linewidth=3, linestyle='--')
l, = ax.plot(x, np.cumsum(data2), color='orange', linewidth=2)
l.set_linestyle(':');

Colores

Matplotlib tiene una gama de colores muy flexible que se acepta para la mayoría de los artistas; consulte el tutorial de colores para obtener una lista de especificaciones. Algunos artistas tomarán varios colores. es decir, para una scatterparcela, el borde de los marcadores puede ser de diferentes colores desde el interior:

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.scatter(data1, data2, s=50, facecolor='C0', edgecolor='k');

<matplotlib.collections.PathCollection object at 0x7f2cddcf8280>

Anchos de línea, estilos de línea y tamaños de marcador

Los anchos de línea suelen estar en puntos tipográficos (1 pt = 1/72 de pulgada) y están disponibles para artistas que tienen líneas trazadas. Del mismo modo, las líneas trazadas pueden tener un estilo de línea. Vea el ejemplo de estilos de línea .

El tamaño del marcador depende del método que se utilice. plotespecifica el tamaño del marcador en puntos y generalmente es el "diámetro" o el ancho del marcador. scatterespecifica el tamaño del marcador como aproximadamente proporcional al área visual del marcador. Hay una variedad de estilos de marcadores disponibles como códigos de cadena (consulte markers), o los usuarios pueden definir los suyos propios MarkerStyle(consulte Referencia de marcador ):

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(data1, 'o', label='data1')
ax.plot(data2, 'd', label='data2')
ax.plot(data3, 'v', label='data3')
ax.plot(data4, 's', label='data4')
ax.legend();

<matplotlib.legend.Legend object at 0x7f2cfa946650>

Etiquetado de parcelas

Etiquetas de ejes y texto

set_xlabel, set_ylabely set_titlese utilizan para agregar texto en las ubicaciones indicadas (consulte Texto en gráficos de Matplotlib para obtener más información). El texto también se puede agregar directamente a las parcelas usando text:

mu, sigma = 115, 15
x = mu + sigma * np.random.randn(10000)
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
# the histogram of the data
n, bins, patches = ax.hist(x, 50, density=True, facecolor='C0', alpha=0.75)

ax.set_xlabel('Length [cm]')
ax.set_ylabel('Probability')
ax.set_title('Aardvark lengths\n (not really)')
ax.text(75, .025, r'$\mu=115,\ \sigma=15$')
ax.axis([55, 175, 0, 0.03])
ax.grid(True);

Todas las textfunciones devuelven una matplotlib.text.Text instancia. Al igual que con las líneas anteriores, puede personalizar las propiedades pasando argumentos de palabras clave a las funciones de texto:

t = ax.set_xlabel('my data', fontsize=14, color='red')

Estas propiedades se tratan con más detalle en Propiedades y diseño del texto .

Uso de expresiones matemáticas en el texto

Matplotlib acepta expresiones de ecuación TeX en cualquier expresión de texto. Por ejemplo para escribir la expresión\(\sigma_i=15\)en el título, puede escribir una expresión TeX rodeada de signos de dólar:

ax.set_title(r'$\sigma_i=15$')

donde la rcadena que precede a la del título significa que la cadena es una cadena sin procesar y no debe tratar las barras invertidas como escapes de Python. Matplotlib tiene un analizador de expresiones TeX y un motor de diseño incorporados, y envía sus propias fuentes matemáticas; para obtener más detalles, consulte Escritura de expresiones matemáticas . También puede usar LaTeX directamente para dar formato a su texto e incorporar la salida directamente en sus figuras de visualización o posdata guardada; consulte Representación de texto con LaTeX .

Anotaciones

También podemos anotar puntos en un gráfico, a menudo conectando una flecha que apunta a xy , a un fragmento de texto en xytext :

fig, ax = plt.subplots(figsize=(5, 2.7))

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
line, = ax.plot(t, s, lw=2)

ax.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
            arrowprops=dict(facecolor='black', shrink=0.05))

ax.set_ylim(-2, 2);

(-2.0, 2.0)

En este ejemplo básico, tanto xy como xytext están en coordenadas de datos. Hay una variedad de otros sistemas de coordenadas que uno puede elegir; consulte Anotación básica y Anotaciones avanzadas para obtener más detalles. También se pueden encontrar más ejemplos en Anotación de parcelas .

Leyendas

A menudo queremos identificar líneas o marcadores con un Axes.legend:

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(np.arange(len(data1)), data1, label='data1')
ax.plot(np.arange(len(data2)), data2, label='data2')
ax.plot(np.arange(len(data3)), data3, 'd', label='data3')
ax.legend();

<matplotlib.legend.Legend object at 0x7f2cde2aaa40>

Las leyendas en Matplotlib son bastante flexibles en diseño, ubicación y qué artistas pueden representar. Se discuten en detalle en la guía Leyenda .

Escalas de eje y marcas

Cada eje tiene dos (o tres) Axisobjetos que representan los ejes x e y. Estos controlan la escala del Eje, los localizadores de ticks y los formateadores de ticks . Se pueden adjuntar ejes adicionales para mostrar más objetos de eje.

Escalas

Además de la escala lineal, Matplotlib proporciona escalas no lineales, como una escala logarítmica. Dado que las escalas logarítmicas se utilizan tanto, también existen métodos directos como loglog, semilogxy semilogy. Hay una serie de escalas (consulte Escalas para ver otros ejemplos). Aquí configuramos la escala manualmente:

fig, axs = plt.subplots(1, 2, figsize=(5, 2.7), layout='constrained')
xdata = np.arange(len(data1))  # make an ordinal for this
data = 10**data1
axs[0].plot(xdata, data)

axs[1].set_yscale('log')
axs[1].plot(xdata, data);

[<matplotlib.lines.Line2D object at 0x7f2cde4a5930>]

La escala establece la asignación de valores de datos al espaciado a lo largo del eje. Esto sucede en ambas direcciones y se combina en una transformación , que es la forma en que Matplotlib asigna coordenadas de datos a ejes, figuras o coordenadas de pantalla. Ver Tutorial de Transformaciones .

Localizadores de ticks y formateadores

Cada Axis tiene un localizador de ticks y un formateador que elige en qué parte de los objetos del Axis colocar marcas de ticks. Una interfaz simple para esto es set_xticks:

fig, axs = plt.subplots(2, 1, layout='constrained')
axs[0].plot(xdata, data1)
axs[0].set_title('Automatic ticks')

axs[1].plot(xdata, data1)
axs[1].set_xticks(np.arange(0, 100, 30), ['zero', '30', 'sixty', '90'])
axs[1].set_yticks([-1.5, 0, 1.5])  # note that we don't need to specify labels
axs[1].set_title('Manual ticks');

Text(0.5, 1.0, 'Manual ticks')

Diferentes escalas pueden tener diferentes localizadores y formateadores; por ejemplo, la escala logarítmica anterior utiliza LogLocatory LogFormatter. Vea Localizadores de Tick y Formateadores de Tick para otros formateadores y localizadores e información para escribir el suyo propio.

Trazado de fechas y cadenas

Matplotlib puede manejar el trazado de matrices de fechas y matrices de cadenas, así como números de coma flotante. Estos obtienen localizadores y formateadores especiales según corresponda. Para fechas:

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
dates = np.arange(np.datetime64('2021-11-15'), np.datetime64('2021-12-25'),
                  np.timedelta64(1, 'h'))
data = np.cumsum(np.random.randn(len(dates)))
ax.plot(dates, data)
cdf = mpl.dates.ConciseDateFormatter(ax.xaxis.get_major_locator())
ax.xaxis.set_major_formatter(cdf);

Para obtener más información, consulte los ejemplos de fechas (por ejemplo, etiquetas de marca de fecha )

Para cadenas, obtenemos trazado categórico (ver: Trazado de variables categóricas ).

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
categories = ['turnips', 'rutabaga', 'cucumber', 'pumpkins']

ax.bar(categories, np.random.rand(len(categories)));

<BarContainer object of 4 artists>

Una advertencia sobre el trazado categórico es que algunos métodos de análisis de archivos de texto devuelven una lista de cadenas, incluso si todas las cadenas representan números o fechas. Si pasa 1000 cadenas, Matplotlib pensará que se refiere a 1000 categorías y agregará 1000 marcas a su gráfico.

Objetos de eje adicionales

Trazar datos de diferente magnitud en un gráfico puede requerir un eje y adicional. Tal eje se puede crear usando twinxpara agregar nuevos ejes con un eje x invisible y un eje y posicionado a la derecha (análogamente a twiny). Consulte Gráficos con diferentes escalas para ver otro ejemplo.

De manera similar, puede agregar una secondary_xaxiso secondary_yaxistener una escala diferente a la del eje principal para representar los datos en diferentes escalas o unidades. Consulte Eje secundario para obtener más ejemplos.

fig, (ax1, ax3) = plt.subplots(1, 2, figsize=(7, 2.7), layout='constrained')
l1, = ax1.plot(t, s)
ax2 = ax1.twinx()
l2, = ax2.plot(t, range(len(t)), 'C1')
ax2.legend([l1, l2], ['Sine (left)', 'Straight (right)'])

ax3.plot(t, s)
ax3.set_xlabel('Angle [rad]')
ax4 = ax3.secondary_xaxis('top', functions=(np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')

Text(0.5, 509.6660000000001, 'Angle [°]')

de datos mapeados en color

A menudo, queremos tener una tercera dimensión en una trama representada por colores en un mapa de colores. Matplotlib tiene varios tipos de gráficos que hacen esto:

X, Y = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))
Z = (1 - X/2 + X**5 + Y**3) * np.exp(-X**2 - Y**2)

fig, axs = plt.subplots(2, 2, layout='constrained')
pc = axs[0, 0].pcolormesh(X, Y, Z, vmin=-1, vmax=1, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[0, 0])
axs[0, 0].set_title('pcolormesh()')

co = axs[0, 1].contourf(X, Y, Z, levels=np.linspace(-1.25, 1.25, 11))
fig.colorbar(co, ax=axs[0, 1])
axs[0, 1].set_title('contourf()')

pc = axs[1, 0].imshow(Z**2 * 100, cmap='plasma',
                          norm=mpl.colors.LogNorm(vmin=0.01, vmax=100))
fig.colorbar(pc, ax=axs[1, 0], extend='both')
axs[1, 0].set_title('imshow() with LogNorm()')

pc = axs[1, 1].scatter(data1, data2, c=data3, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[1, 1], extend='both')
axs[1, 1].set_title('scatter()')

Text(0.5, 1.0, 'scatter()')

Mapas de colores

Todos estos son ejemplos de Artistas que derivan de ScalarMappable objetos. Todos pueden establecer un mapeo lineal entre vmin y vmax en el mapa de colores especificado por cmap . Matplotlib tiene muchos mapas de colores para elegir ( Elegir mapas de colores en Matplotlib ), puede crear el suyo propio ( Crear mapas de colores en Matplotlib ) o descargarlos como paquetes de terceros .

Normalizaciones

A veces queremos una asignación no lineal de los datos al mapa de colores, como en el LogNormejemplo anterior. Hacemos esto proporcionando ScalarMappable con el argumento de norma en lugar de vmin y vmax . Se muestran más normalizaciones en Normalización de mapa de colores .

Barras de color

Agregar un colorbarda una clave para relacionar el color con los datos subyacentes. Las barras de colores son artistas a nivel de figura y están adjuntas a un ScalarMappable (donde obtienen su información sobre la norma y el mapa de colores) y generalmente roban espacio de los ejes principales. La colocación de barras de colores puede ser compleja: consulte Colocación de barras de colores para obtener más detalles. También puede cambiar la apariencia de las barras de colores con la palabra clave extender para agregar flechas a los extremos y reducir y orientar para controlar el tamaño. Finalmente, la barra de colores tendrá localizadores y formateadores predeterminados apropiados a la norma. Estos se pueden cambiar como para otros objetos Axis.

Trabajando con múltiples Figuras y Ejes

Puede abrir varias Figuras con varias llamadas a o . Al mantener las referencias de objetos, puede agregar Artistas a cualquiera de las Figuras.fig = plt.figure()fig2, ax = plt.subplots()

Los ejes múltiples se pueden agregar de varias maneras, pero la más básica es la plt.subplots()que se usó anteriormente. Se pueden lograr diseños más complejos, con objetos Axes que abarcan columnas o filas, utilizando subplot_mosaic.

fig, axd = plt.subplot_mosaic([['upleft', 'right'],
                               ['lowleft', 'right']], layout='constrained')
axd['upleft'].set_title('upleft')
axd['lowleft'].set_title('lowleft')
axd['right'].set_title('right');

Text(0.5, 1.0, 'right')

Matplotlib tiene herramientas bastante sofisticadas para organizar ejes: consulte Organización de varios ejes en una figura y Composición de figuras complejas y semánticas .

Más lectura

Para obtener más tipos de gráficos, consulte Tipos de gráficos y la referencia de la API , en particular, la API de ejes .