Tutorial de Pyplot

Una introducción a la interfaz de pyplot. Consulte también la Guía de inicio rápido para obtener una descripción general de cómo funciona Matplotlib y las Interfaces de aplicación (API) de Matplotlib para obtener una explicación de las compensaciones entre las API de usuario admitidas.

Introducción a pyplot

matplotlib.pyplotes una colección de funciones que hacen que matplotlib funcione como MATLAB. Cada pyplotfunción realiza algún cambio en una figura: por ejemplo, crea una figura, crea un área de trazado en una figura, traza algunas líneas en un área de trazado, decora el trazado con etiquetas, etc.

En matplotlib.pyplotvarios estados se conservan a través de las llamadas a funciones, de modo que realiza un seguimiento de cosas como la figura actual y el área de trazado, y las funciones de trazado se dirigen a los ejes actuales (tenga en cuenta que "ejes" aquí y en la mayoría de los lugares en la documentación se refiere a los ejes parte de una figura y no el término matemático estricto para más de un eje).

Nota

la API de pyplot implícita generalmente es menos detallada pero tampoco tan flexible como la API explícita. La mayoría de las llamadas a funciones que ve aquí también se pueden llamar como métodos desde un Axesobjeto. Recomendamos navegar por los tutoriales y ejemplos para ver cómo funciona. Consulte Interfaces de aplicación (API) de Matplotlib para obtener una explicación de la compensación de las API de usuario admitidas.

Generar visualizaciones con pyplot es muy rápido:

import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Quizás se pregunte por qué el eje x varía de 0 a 3 y el eje y de 1 a 4. Si proporciona una sola lista o matriz a plot, matplotlib asume que es una secuencia de valores y, y genera automáticamente los valores x para usted. Dado que los rangos de Python comienzan con 0, el vector x predeterminado tiene la misma longitud que y pero comienza con 0. Por lo tanto, los datos de x son .[0, 1, 2, 3]

plotes una función versátil y tomará un número arbitrario de argumentos. Por ejemplo, para graficar x contra y, puedes escribir:

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])

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

Formateando el estilo de tu trama

Para cada par de argumentos x, y, hay un tercer argumento opcional que es la cadena de formato que indica el color y el tipo de línea del gráfico. Las letras y los símbolos de la cadena de formato son de MATLAB y usted concatena una cadena de color con una cadena de estilo de línea. La cadena de formato predeterminada es 'b-', que es una línea azul continua. Por ejemplo, para trazar lo anterior con círculos rojos, emitiría

plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis([0, 6, 0, 20])
plt.show()

Consulte la plotdocumentación para obtener una lista completa de estilos de línea y cadenas de formato. La axisfunción del ejemplo anterior toma una lista y especifica la ventana gráfica de los ejes.[xmin, xmax, ymin, ymax]

Si matplotlib se limitara a trabajar con listas, sería bastante inútil para el procesamiento numérico. En general, utilizará matrices numpy . De hecho, todas las secuencias se convierten internamente en matrices numpy. El siguiente ejemplo ilustra el trazado de varias líneas con diferentes estilos de formato en una llamada de función usando matrices.

import numpy as np

# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)

# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Trazado con cadenas de palabras clave

Hay algunos casos en los que tiene datos en un formato que le permite acceder a variables particulares con cadenas. Por ejemplo, con numpy.recarrayo pandas.DataFrame.

Matplotlib le permite proporcionar dicho objeto con el dataargumento de palabra clave. Si se proporciona, puede generar gráficos con las cadenas correspondientes a estas variables.

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

plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Trazado con variables categóricas

También es posible crear un gráfico usando variables categóricas. Matplotlib le permite pasar variables categóricas directamente a muchas funciones de trazado. Por ejemplo:

names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]

plt.figure(figsize=(9, 3))

plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Propiedades de la línea de control

Las líneas tienen muchos atributos que puede configurar: ancho de línea, estilo de guión, suavizado, etc.; ver matplotlib.lines.Line2D_ Hay varias formas de establecer las propiedades de línea

• Utilice argumentos de palabras clave:

  plt.plot(x, y, linewidth=2.0)
  

• Utilice los métodos setter de una Line2Dinstancia. plotdevuelve una lista de Line2Dobjetos; por ejemplo, . En el siguiente código, supondremos que solo tenemos una línea, por lo que la lista devuelta tiene una longitud de 1. Usamos el desempaquetado de tuplas para obtener el primer elemento de esa lista:line1, line2 = plot(x1, y1, x2, y2)line,

  line, = plt.plot(x, y, '-')
  line.set_antialiased(False) # turn off antialiasing
  

• uso setp_ El siguiente ejemplo utiliza una función de estilo MATLAB para establecer varias propiedades en una lista de líneas. setpfunciona de forma transparente con una lista de objetos o un solo objeto. Puede usar argumentos de palabras clave de python o pares de cadena/valor de estilo MATLAB:

  lines = plt.plot(x1, y1, x2, y2)
  # use keyword arguments
  plt.setp(lines, color='r', linewidth=2.0)
  # or MATLAB style string value pairs
  plt.setp(lines, 'color', 'r', 'linewidth', 2.0)
  

Aquí están las Line2Dpropiedades disponibles.

Propiedad	Tipo de valor
alfa	flotar
animado	[Verdadero | Falso]
suavizado o aa	[Verdadero | Falso]
clip_box	una instancia de matplotlib.transform.Bbox
clip_en	[Verdadero | Falso]
clip_path	una instancia de ruta y una instancia de transformación, un parche
color o c	cualquier color matplotlib
contiene	la función de prueba de impacto
dash_capstyle	[ 'butt'| 'round'| 'projecting']
dash_joinstyle	[ 'miter'| 'round'| 'bevel']
guiones	secuencia de encendido/apagado de tinta en puntos
datos	(np.array xdata, np.array ydata)
figura	una instancia de matplotlib.figure.Figure
etiqueta	cualquier cadena
estilo de línea o ls	[ '-'| '--'| '-.'| ':'| 'steps'| ...]
ancho de línea o lw	valor flotante en puntos
marcador	[ '+'| ','| '.'| '1'| '2'| '3'| '4']
marcadorbordecolor o mec	cualquier color matplotlib
ancho del borde del marcador o mew	valor flotante en puntos
color de la cara del marcador o mfc	cualquier color matplotlib
tamaño de marcador o ms	flotar
marcar cada	[ Ninguno | entero | (comenzando, zancada)]
recogedor	utilizado en la selección de línea interactiva
radio de pico	el radio de selección de selección de línea
solid_capstyle	[ 'butt'| 'round'| 'projecting']
solid_joinstyle	[ 'miter'| 'round'| 'bevel']
transformar	una instancia matplotlib.transforms.Transform
visible	[Verdadero | Falso]
datos x	np.matriz
ydatos	np.matriz
orden Z	cualquier número

Para obtener una lista de propiedades de línea configurables, llame a la setpfunción con una línea o líneas como argumento

In [69]: lines = plt.plot([1, 2, 3])

In [70]: plt.setp(lines)
  alpha: float
  animated: [True | False]
  antialiased or aa: [True | False]
  ...snip

Trabajando con múltiples figuras y ejes

MATLAB y pyplot, tienen el concepto de la figura actual y los ejes actuales. Todas las funciones de trazado se aplican a los ejes actuales. La función gcadevuelve los ejes actuales (una matplotlib.axes.Axesinstancia) y gcfdevuelve la figura actual (una matplotlib.figure.Figureinstancia). Normalmente, no tienes que preocuparte por esto, porque todo se soluciona entre bastidores. A continuación se muestra un script para crear dos tramas secundarias.

def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

La figurellamada aquí es opcional porque se creará una figura si no existe, al igual que se creará un Eje (equivalente a una subplot()llamada explícita) si no existe. La subplotllamada especifica dónde varía de 1 a . Las comas en la llamada son opcionales if . Entonces es idéntico a .numrows, numcols, plot_numberplot_numbernumrows*numcolssubplotnumrows*numcols<10subplot(211)subplot(2, 1, 1)

Puede crear un número arbitrario de subparcelas y ejes. Si desea colocar un eje manualmente, es decir, no en una cuadrícula rectangular, use axes, que le permite especificar la ubicación donde todos los valores están en coordenadas fraccionarias (0 a 1). Consulte Demostración de ejes para ver un ejemplo de cómo colocar ejes manualmente y Múltiples subparcelas para ver un ejemplo con muchas subparcelas.axes([left, bottom, width, height])

Puede crear varias cifras utilizando varias figurellamadas con un número de cifra creciente. Por supuesto, cada figura puede contener tantos ejes y tramas secundarias como tu corazón desee:

import matplotlib.pyplot as plt
plt.figure(1)                # the first figure
plt.subplot(211)             # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212)             # the second subplot in the first figure
plt.plot([4, 5, 6])


plt.figure(2)                # a second figure
plt.plot([4, 5, 6])          # creates a subplot() by default

plt.figure(1)                # figure 1 current; subplot(212) still current
plt.subplot(211)             # make subplot(211) in figure1 current
plt.title('Easy as 1, 2, 3') # subplot 211 title

Puede borrar la figura actual con clf y los ejes actuales con cla. Si le resulta molesto que los estados (específicamente la imagen actual, la figura y los ejes) se mantengan detrás de escena, no se desespere: esto es solo un delgado envoltorio con estado alrededor de una API orientada a objetos, que puede usar en su lugar (ver tutorial del artista )

Si está haciendo muchas figuras, debe tener en cuenta una cosa más: la memoria requerida para una figura no se libera por completo hasta que la figura se cierra explícitamente con close. Eliminar todas las referencias a la figura y/o usar el administrador de ventanas para eliminar la ventana en la que aparece la figura en la pantalla no es suficiente, porque pyplot mantiene las referencias internas hasta close que se llama.

Trabajando con texto

textse puede usar para agregar texto en una ubicación arbitraria, y xlabel, ylabely titlese usan para agregar texto en las ubicaciones indicadas (consulte Text in Matplotlib Plots para obtener un ejemplo más detallado)

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()

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 o usando setp:

t = plt.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:

plt.title(r'$\sigma_i=15$')

Lo rque precede a la cadena de título es importante: significa que la cadena es una cadena sin formato y no debe tratar las barras diagonales inversas como escapes de python. matplotlib tiene un analizador de expresiones TeX y un motor de diseño integrados, y envía sus propias fuentes matemáticas; para obtener más información, consulte Escritura de expresiones matemáticas . Por lo tanto, puede usar texto matemático en todas las plataformas sin necesidad de una instalación de TeX. Para aquellos que tienen LaTeX y dvipng instalados, también pueden usar LaTeX 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 .

Anotando texto

Los usos de la función básica textanterior colocan el texto en una posición arbitraria en los ejes. Un uso común para el texto es anotar alguna característica de la trama, y ​​el annotatemétodo proporciona una funcionalidad de ayuda para facilitar las anotaciones. En una anotación, hay dos puntos a considerar: la ubicación que se anota representada por el argumento xyy la ubicación del texto xytext. Ambos argumentos son tuplas.(x, y)

ax = plt.subplot()

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

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

plt.ylim(-2, 2)
plt.show()

En este ejemplo básico, tanto la xy(punta de flecha) como xytext las ubicaciones (ubicación del texto) 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. Se pueden encontrar más ejemplos en Anotación de parcelas .

Ejes logarítmicos y otros no lineales

matplotlib.pyplotadmite no solo escalas de ejes lineales, sino también escalas logarítmicas y logit. Esto se usa comúnmente si los datos abarcan muchos órdenes de magnitud. Cambiar la escala de un eje es fácil:

plt.xscale('registro')

A continuación se muestra un ejemplo de cuatro gráficos con los mismos datos y diferentes escalas para el eje y.

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the open interval (0, 1)
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure()

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)

# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)

# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.01)
plt.title('symlog')
plt.grid(True)

# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
                    wspace=0.35)

plt.show()

También es posible añadir su propia escala, consulte matplotlib.scalelos detalles.