import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# Datos para plotting
t = np.arange(0.0, 2.0, 0.01) # np.arange(inicio,fin,paso)
y = np.sin(2 * np.pi * t)
# Plotting los datos
plt.xlabel('Etiqueta en el eje x')
plt.ylabel('Etiqueta en el eje y')
plt.title('Mi primer plot')
plt.grid() # poner grilla
plt.plot(t,y)
plt.show()
Matplotlib permite ajustar los valores que vienen por defecto, esto con el fin de crear un gráfico a nuestras necesidades. A continuación se dará paso a cómo modificar el color, cambiar los ejes, el ancho de la linea, insertar leyendas, entre otros.
# Crear una nueva figura de tamaño 8x6 pulgadas, usando 100 puntos por pulgada
plt.figure(figsize=(8,6))
plt.subplot(111)
# Establece un marco para crear nuestro plot al interior de la figura recién creada
x = np.linspace(-np.pi, np.pi, 256) # np.linspace(inicio,fin,particiones)
y1,y2 = np.cos(x), np.sin(x)
# graficar la función y1 (coseno) usando color azul con una linea continua de ancho 1
plt.plot(x, y1, color="blue", linewidth=1.0, linestyle="-")
# graficar la función y2 (seno) usando color rojo con un estilo de línea "dot-dashed" y ancho 1
plt.plot(x, y2, color="red", linewidth=1.0, linestyle="-.")
#Mostrar resultado en la pantalla
plt.show()
plt.figure(figsize=(8,6))
plt.subplot(111)
x = np.linspace(-np.pi, np.pi, 256)
y1,y2 = np.cos(x), np.sin(x)
plt.plot(x, y1, color="blue", linewidth=1.3, linestyle="-")
plt.plot(x, y2, color="red", linewidth=1.4, linestyle="-.")
# ajustar x,y ticks
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],[r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks([-1, 0, +1],[r'$-1$', r'$0$', r'$+1$'])
# ajustar límites
plt.xlim(x.min()*1.1, x.max()*1.1)
#Mostrar resultado en la pantalla
plt.show()
Las spines son las líneas que detentan las marcas de los ejes y sirven como referencia del área cubierta por los datos. Se pueden colocar en posiciones arbitrarias, aunque hasta ahora estaban en el borde de la figura. Cambiaremos eso para tenerlos en el medio.
plt.figure(figsize=(8,6))
# Note que el recuadro que contendrá a la figura puede ser asignado a una
# variable, de modo que para modificar las propiedades del gráfico lo hacemos
# directamente a través de los atributos de esa variable
ax = plt.subplot(111)
# mover espinas
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
x = np.linspace(-np.pi, np.pi, 256)
y1,y2 = np.cos(x), np.sin(x)
# En la siguiente línea, vamos a añadir un label a cada línea para insertar legendas
plt.plot(x, y1, color="blue", linewidth=1.3, linestyle="-",label = 'cos(X)')
plt.plot(x, y2, color="red", linewidth=1.4, linestyle="-.",label = 'sin(X)')
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],[r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks([-1, 0, +1],[r'$-1$', r'$0$', r'$+1$'])
plt.xlim(x.min()*1.1, x.max()*1.1)
# añadir legendas
plt.legend()
plt.show()
Vamos a marcar algunos puntos interesantes usando el comando annotate. Elegimos el valor 2π/3 y queremos marcar tanto el seno como el coseno. Primero dibujaremos un marcador en la curva, así como una línea punteada recta. Luego, usaremos el comando annotate para mostrar texto con una flecha.
plt.figure(figsize=(8,6))
ax = plt.subplot(111)
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))
x = np.linspace(-np.pi, np.pi, 256)
y1,y2 = np.cos(x), np.sin(x)
# añadir label para insertar legendas
plt.plot(x, y1, color="blue", linewidth=1.3, linestyle="-",label = 'cos(X)')
plt.plot(x, y2, color="red", linewidth=1.4, linestyle="-.",label = 'sin(X)')
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],[r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks([-1, 0, +1],[r'$-1$', r'$0$', r'$+1$'])
plt.xlim(x.min()*1.1, x.max()*1.1)
# Anotación de puntos
t = 2*np.pi/3
# La siguiente línea crea el segmento vertical azul
plt.plot([t,t],[0,np.cos(t)],color ='blue', linewidth=1.5, linestyle="--")
# La siguiente línea grafica el punto deseado. El uso del formato "ob" indica que
# queremos usar marcadores circulares de color azul.
# Se sugiere ver la ayuda plt.plot para conocer todas las posibilidades sobre los
# tipos de marcadores, tipos de línea, etc.
plt.plot([t],[np.cos(t)], "ob",markersize = 7)
# El uso de la r antes de una secuencia de caracteres nos permite utilizar la sintaxis
# de latex para embellecer los textos. Examine la yuda del comando en caso de dudas
plt.annotate(r'$\sin(\frac{2\pi}{3})=\frac{\sqrt{3}}{2}$',
xy=(t, np.sin(t)), xycoords='data',
xytext=(+10, +30), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
plt.plot([t,t],[0,np.sin(t)],color ='red', linewidth=1.5, linestyle="--")
plt.plot([t],[np.sin(t)], "or",markersize = 7)
plt.annotate(r'$\cos(\frac{2\pi}{3})=-\frac{1}{2}$',
xy=(t, np.cos(t)), xycoords='data',
xytext=(-90, -50), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
# ubicar la legenda en la parte superior izquiera de la ventana, y que no tenga recuadro alrededor
plt.legend(loc='upper left', frameon=False)
plt.show()
# Funcion 1
x1 = np.arange(0.0, 5.0, 0.1) # np.arange(inicio,fin,paso)
y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)
# Funcion 2
x2 = np.arange(0.0, 2.0, 0.05)
y2 = np.cos(2 * np.pi * x2)
# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
plt.subplot(2, 1, 1)
plt.plot(x1, y1, 'o-')
plt.title('Una figura con 2 subplots')
plt.ylabel('label 1')
# plt.subplot(# de filas, # de columnas, # del recuadro donde queremos hacer esta gráfcia en particular)
plt.subplot(2, 1, 2)
plt.plot(x2, y2, '.-')
plt.xlabel('Etiqueta en el eje x')
plt.ylabel('label 2')
plt.show()
from pylab import *
import matplotlib.gridspec as gridspec
G = gridspec.GridSpec(3, 3) # especificar la geometía de la grilla, una matriz de 3x3
axes_1 = plt.subplot(G[0, :]) # tomar la fila 0, todas las columnas
xticks([]), yticks([]) # quitar los ticks
x1 = np.arange(0.0, 5.0, 0.1)
y1 = np.cos(2 * np.pi * x1) * np.exp(-x1)
plt.plot(x1, y1, 'o-')
axes_2 = subplot(G[1,:-1])
xticks([]), yticks([])
x2 = np.arange(0.0, 2.0, 0.05)
y2 = np.cos(2 * np.pi * x2)
plt.plot(x2, y2, '.-',color="b")
axes_3 = subplot(G[1:, -1])
xticks([]), yticks([])
plt.plot(x2, y2, '.-',color="green")
axes_4 = subplot(G[-1,0])
xticks([]), yticks([])
plt.plot(x2, y2, '.-',color="y")
axes_5 = subplot(G[-1,-2])
xticks([]), yticks([])
plt.plot(x1, y1, 'o-',color="red")
plt.show()
Matplotlib puede visualizar imagenes usando la función imshow()
import matplotlib.cm as cm
plt.figure(figsize=(8,6))
# Valores a muestrear en los ejes X y Y
x = y = np.arange(-3.0, 3.0, 0.25) # np.arange(inicio,fin,paso)
# Creación de una cuadrícula 2D, es decir, de las parejas (X,Y)
# utilizando los valores de X y Y creados individualmente
X, Y = np.meshgrid(x, y) # forma una matrix cuadrada con X
# Llenamos una matriz 2D con una función que depende de X y Y
# verifique la forma de la matriz con Z1.shape
def f(x,y):
return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
Z1 = f(X,Y)
# Note el uso de colormap. Explore la ayuda de imshow para entender los demás parámetros
plt.imshow(Z1, cmap=cm.gray, vmax=abs(Z1).max(), extent=[-3, 3, -3, 3], vmin=-abs(Z1).max())
# Agregue opcionalmente una barra diagnóstica de color descomentando la siguiente línea
# plt.colorbar()
plt.show()
La función hist() genera automáticamente histogramas y devuelve los recuentos o probabilidades del contenedor
# example data
mu = 100 # la media
sigma = 15 # desviación estandar
x = mu + sigma * np.random.randn(437)
num_bins = 50
fig, ax = plt.subplots()
# Histograma de los datos
n, bins, patches = ax.hist(x, num_bins, density=1)
# add a 'best fit' line
y = ((1 / (np.sqrt(2 * np.pi) * sigma)) *
np.exp(-0.5 * (1 / sigma * (bins - mu))**2))
ax.plot(bins, y, '--')
ax.set_xlabel('Smarts')
ax.set_ylabel('Densidad de Probabilidad')
ax.set_title(r'Histograma de IQ: $\mu=100$, $\sigma=15$')
plt.show()
La función pie () le permite crear gráficos circulares. Las características opcionales incluyen el etiquetado automático del porcentaje de área, la explosión de una o más cuñas desde el centro del pastel y un efecto de sombra.
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0) # solo se explota la segunda rebanada (i.e. 'Hogs')
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',startangle=90)
ax1.axis('equal') # garantiza que el pastel se dibuje como un círculo.
plt.show()
La función scatter() hace un diagrama de dispersión con tamaño (opcional) y argumentos de color. Este ejemplo representa los cambios en el precio de las acciones de Google, con tamaños de marcador que reflejan el volumen de negociación y los colores que varían con el tiempo. Aquí, el atributo alfa se usa para hacer marcadores circulares semitransparentes.
n = 1024
X = np.random.normal(0,1,n)
Y = np.random.normal(0,1,n)
T = np.arctan2(Y,X)
plt.axes([0.025,0.025,0.95,0.95])
plt.xlim(-1.5,1.5), plt.xticks([])
plt.ylim(-1.5,1.5), plt.yticks([])
plt.scatter(X,Y,s=75, c=T, alpha=.5)
plt.show()
Las funciones semilogx(), semilogy() y loglog() simplifican la creación de diagramas logarítmicos.
# Create figure
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
# Data for plotting
t = np.arange(0.01, 20.0, 0.01)
# log y axis
ax1.semilogy(t, np.exp(-t / 5.0))
ax1.set(title='semilogy')
ax1.grid()
# log x axis
ax2.semilogx(t, np.sin(2 * np.pi * t))
ax2.set(title='semilogx')
ax2.grid()
# log x and y axis
ax3.loglog(t, 20 * np.exp(-t / 10.0), basex=2)
ax3.set(title='loglog base 2 on x')
ax3.grid()
# With errorbars: clip non-positive values
# Use new data for plotting
x = 10.0**np.linspace(0.0, 2.0, 20)
y = x**2.0
ax4.set_xscale("log", nonposx='clip')
ax4.set_yscale("log", nonposy='clip')
ax4.set(title='Errorbars go negative')
ax4.errorbar(x, y, xerr=0.1 * x, yerr=5.0 + 0.75 * y)
# ylim debe configurarse después de la barra de errores para permitir que la barra de errores escale los
# límites automáticamente
ax4.set_ylim(ymin=0.1)
fig.tight_layout()
plt.show()
<ipython-input-13-02f163a56c51>:18: MatplotlibDeprecationWarning: The 'basex' parameter of __init__() has been renamed 'base' since Matplotlib 3.3; support for the old name will be dropped two minor releases later.
ax3.loglog(t, 20 * np.exp(-t / 10.0), basex=2)
<ipython-input-13-02f163a56c51>:27: MatplotlibDeprecationWarning: The 'nonposx' parameter of __init__() has been renamed 'nonpositive' since Matplotlib 3.3; support for the old name will be dropped two minor releases later.
ax4.set_xscale("log", nonposx='clip')
<ipython-input-13-02f163a56c51>:28: MatplotlibDeprecationWarning: The 'nonposy' parameter of __init__() has been renamed 'nonpositive' since Matplotlib 3.3; support for the old name will be dropped two minor releases later.
ax4.set_yscale("log", nonposy='clip')
La función polar () genera gráficos polares
r = np.arange(0, 2, 0.01) # np.arange(inicio,fin,paso)
theta = 2 * np.pi * r
ax = plt.subplot(111, projection='polar')
ax.plot(theta, r)
ax.set_rmax(2)
ax.set_rticks([0.5, 1, 1.5, 2]) # Less radial ticks
ax.set_rlabel_position(-22.5) # Move radial labels away from plotted line
ax.grid(True)
ax.set_title("A line plot on a polar axis", va='bottom')
plt.show()
# Vamos a graficar la misma función del ejemplo de imshow, esta vez mostrando sus
# contornos o curvas de nivel
def f(x,y):
return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
n = 256
x = np.linspace(-3,3,n)
y = np.linspace(-3,3,n)
X,Y = np.meshgrid(x,y)
# creamos una ventana(axes) en la cuál enmarcar nuestra figura
# los números definen una posición para los bordes respecto a la figura total
plt.axes([0.025,0.025,0.95,0.95])
plt.contourf(X, Y, f(X,Y), 8, alpha=.75, cmap=plt.cm.hot)
C = plt.contour(X, Y, f(X,Y), 8, colors='black')
plt.clabel(C, inline=1, fontsize=10)
plt.xticks([]), plt.yticks([])
plt.show()
ax = plt.axes([0.025,0.025,1,1], polar=True)
N = 20
theta = np.arange(0.0, 2*np.pi, 2*np.pi/N)
radii = 10*np.random.rand(N)
width = np.pi/4*np.random.rand(N)
bars = plt.bar(theta, radii, width=width, bottom=0.0)
for r,bar in zip(radii, bars):
bar.set_facecolor( plt.cm.jet(r/10.))
bar.set_alpha(0.5)
ax.set_xticklabels([])
ax.set_yticklabels([])
plt.show()
n = 12
X = np.arange(n)
Y1 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)
Y2 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)
plt.axes([0.025,0.025,1,1])
plt.bar(X, +Y1, facecolor='#c875c4', edgecolor='white')
plt.bar(X, -Y2, facecolor='#ff9999', edgecolor='white')
for x,y in zip(X,Y1):
plt.text(x+0.4, y+0.05, '%.2f' % y, ha='center', va= 'bottom')
for x,y in zip(X,Y2):
plt.text(x+0.4, -y-0.05, '%.2f' % y, ha='center', va= 'top')
plt.xlim(-.5,n), plt.xticks([])
plt.ylim(-1.25,+1.25), plt.yticks([])
plt.show()
n = 8
X,Y = np.mgrid[0:n,0:n]
T = np.arctan2(Y-n/2.0, X-n/2.0)
R = 10+np.sqrt((Y-n/2.0)**2+(X-n/2.0)**2)
U,V = R*np.cos(T), R*np.sin(T)
plt.axes([0.025,0.025,0.95,0.95])
plt.quiver(X,Y,U,V,R, alpha=.5)
plt.quiver(X,Y,U,V, edgecolor='k', facecolor='None', linewidth=.5)
plt.xlim(-1,n), plt.xticks([])
plt.ylim(-1,n), plt.yticks([])
plt.show()
El kit de herramientas mplot3d tiene soporte para gráficos simples en 3D, que incluyen superficie, estructura alámbrica, dispersión y gráficos de barras.
# Vamos a graficar la misma función del ejemplo de imshow, esta vez mostrándola en 3D
from mpl_toolkits.mplot3d import Axes3D
x = y = np.arange(-3.0, 3.0, 0.25)
X, Y = np.meshgrid(x, y)
def f(x,y):
return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
Z1 = f(X,Y)
ax = Axes3D(plt.figure()) # creando el cubo
ax.plot_surface(X,Y,Z1,vmax=abs(Z1).max(), vmin=-abs(Z1).max(), cmap=cm.RdYlGn, rstride=1,cstride=1)
plt.show()
