Fullscreen
Loading...
 
Imprimir Comparte esta página

curso python basico

Gratificando con Matplotlib


Generalidades de Matplotlib


Para ésta parte vamos a usar una terminal de Python (no de iPython que es la que generalmente usamos)

Cargando la librería en el entorno.


Cuando se va a usar la librería se debe de cargar en el entorno (como ya se vio anteriormente)
import matplotlib.pyplot as plt


Las dos zonas principales donde se dibujaran o sobre las que se interactuará serán:
  • figure: Es una instancia de matplotlib.figure.Figure. Y es la ventana donde irá el o los gráficos en sí.
    Sintaxis:
    import matplotlib.pyplot as plt


plt.figure #Se debe de tener en cuenta que ptl en este caso traduce matplotlib
  • axes:: Es una instancia de matplotlib.axes.Axes, que es el gráfico en sí donde se dibujará todo lo que le digamos y está localizada dentro de una figure
    Sintaxis:
    import matplotlib.pyplot as plt


plt.axes #Se debe de tener en cuenta que ptl en este caso traduce matplotlib

Ventanas, y configuración de sesión.


Lo primero que se va a necesitar es que la sesión esté en modo interactivo, esto es: que cada que se realice un cambio en ésta, se muestre automáticamente.
plt.isinteractive()

cuando ejecute esta linea la respuesta es false entonces tiene el modo interactivo desactivado. Para cambiar de modo interactivo de a activo se usa plt.ion() y para regresar al modo interactivo apagado se usa plt.ioff().

  • Ejemplo: Ahora con el modo interactivo encendido, hagamos la primera gráfica. 
    plt.plot([1,7,3,-3,5])

Otras funcionalidades interesantes son las que provee, las funciones asociadas plt, hold() y ishold(), la primera permite decidir si queremos que los gráficos se sobrescriban, que en el mismo gráfico tengamos diferentes gráficas representadas, o para que el gráfico se limpie y se dibuje la nueva gráfica cada vez. La segunda permite saber el estado de hold(). Si usamos plt.ishold() nos responderá True o False.
  • Ejemplo: 
    plt.plot(np.random.rand(10))
plt.plot(np.random.rand(10))
plt.show()

Para borrar todos los gráficos en el modo interactivo se usa plt.clf(), o plt.close() para cerrar la ventana.

También se pueden usar diferentes ventanas de gráficos al mismo tiempo. Esto se hace nombrando a cada una de las ventanas en las que vamos a trabajar cuando se llama plt.figure('nombre').

  • Ejemplo: 
    import matplotlib.pyplot as plt 
import numpy as np

plt.figure('scatter') # Crea una ventana titulada 'scatter'
plt.figure('plot') # Crea una ventana titulada 'plot'
a = np.random.rand(100) # Generamos un vector de valores aleatorios
b = np.random.rand(100) # Generamos otro vector de valores aleatorios
"""Le decimos que la ventana activa en la que vamos a dibujar es la ventana 'scatter'"""
plt.figure('scatter')
plt.scatter(a,b) # Dibujamos un scatterplot en la ventana 'scatter'
plt.figure('plot') # Ahora cambiamos a la ventana 'plot'
plt.plot(a,b)


Si no se quiere dibujar los gráficos en dos ventanas, y mas bien tener varios gráficos en la misma. Es posible hacer eso sin problemas con la ayuda de plt.subplot(). Con plt.subplot() podemos indicar el número de filas y columnas que corresponderán a como dividimos la ventana.

  • Ejemplo: 
    import matplotlib.pyplot as plt


plt.ion() # Nos ponemos en modo interactivo
# Dividimos la ventana en una fila y dos
# columnas y dibujamos el primer gráfico
plt.subplot(1,2,1)
plt.plot((1,2,3,4,5))
# Dividimos la ventana en una fila y dos
# columnas y dibujamos el segundo gráfico
plt.subplot(1,2,2)
plt.plot((5,4,3,2,1))

    • Actividad 1


Modificar características de las gráficas


En el siguiente script se puede ver algunas de las modificaciones que se pueden hacer en las gráficas.
import matplotlib.pyplot as plt

plt.ion() # Nos ponemos en modo interactivo
plt.figure('valores por defecto')# Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.suptitle('Titulo valores por defecto') # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = 'por defecto') # Hacemos el plot
plt.legend(loc = 2)# Colocamos la leyenda en la esquina superior izquierda
plt.rc('lines', linewidth = 2)# A partir de aquí todas las líneas que dibujemos irán con ancho doble
plt.rc('font', size = 18)# A partir de aquí las fuentes que aparezcan en cualquier gráfico en la misma sesión tendrán mayor tamaño


plt.figure('valores modificados')
plt.suptitle('Titulo valores modificados')
plt.plot((1,2,3,4,5),
label = u'linea más ancha y letra más grande')
plt.legend(loc = 1)


Otras posibles configuraciones de la gráfica se pueden ver en la ayuda de ipython y online.


Configuración del gráfico


Con plt.axes(), que sirve para llamar y/o configurar a un crea de gráfico. Podemos definir la posición, el tamaño, el color del {rea del fondo. En el siguiente ejemplo se pueden ver algunas configuraciones.
import matplotlib.pyplot as plt
import numpy as np

plt.ion() # Ponemos la sesión como interactiva si no está
plt.axes() # Coloca un área de gráfico con los valores por defecto
# Dibuja una exponencial de 0 a 10
plt.plot(np.exp(np.linspace(0,10,100)))
# Dibuja una nueva área de gráfica colocada y con ancho y largo definido por [0.2,0.55,0.3,0.3] y con gris como color de fondo
plt.axes([0.2,0.55,0.3,0.3], axisbg = 'gray')
plt.plot(np.sin(np.linspace(0,10,100)), 'b-o', linewidth = 2)


    • Actividad:Modifique los valores del área e identifique que cambia cuando modifica cada número

Es posible usar plt.axes() como sustituto de plt.subplot() si se quiere dibujar gráficos que no tengan que tener una forma ‘regular’ dentro de la ventana. En este caso si se quiere borrar el área del gráfico podemos usar plt.delaxes().
También se puede hacer que no aparezca la ‘caja’ donde se dibuja el gráfico con plt.box() o si no hay ‘caja’ y queremos que aparezca podemos llamar a plt.box() y volver a hacer aparecer la ‘caja’. Otra cosa de utilidad es colocar una rejilla en el gráfico mediante plt.grid().

Nota: Se pueden hacer también axes polares con plt.axes( polar = True), rejillas para polares con plt.rgrid() y plt.thetagrids()

Matplotlib dibuja los ejes tal que se ajusten al gráfico pero si eso no es lo que nos interese en algún momento, entonces se puede hacer uso de plt.axis(). Esta Nos permite definir la longitud de los ejes, si queremos que aparezcan los mismos, si queremos que estos estén escalados,... Si solo nos interesa configurar uno de los ejes y dejar que el otro lo maneje matplotlib podemos usar plt.xlim(), plt.xscale(),plt.ylim() y plt.yscale().
Si queremos dejar el eje x o el eje y con escala logarítmica podemos usar, respectivamente, plt.semilogx() o plt.semilogy(). Podemos dibujar un segundo eje x o un segundo eje y usando plt.twinx() o plt.twiny, respectivamente.
También podemos establecer unos márgenes alrededor de los límites de los ejes usando plt.margins(). Por último, podemos etiquetar nuestros ejes con plt.xlabel() y plt.ylabel()

  • Ejemplo:
    import numpy as np
import matplotlib.pyplot as plt

plt.ion()
plt.plot(np.arange(100), 'b') # Dibujamos una línea recta azul
plt.xlabel('Valores de x') # Ponemos etiqueta al eje x
plt.ylabel(u'Línea azul') # Ponemos etiqueta al eje y
plt.twinx() # Creamos un segundo eje y
# Dibuja una exponencial de 0 a 5 con la y representada en el
# segundo eje y
plt.plot(np.exp(np.linspace(0,5,100)), 'g')
plt.ylabel(u'Línea verde') # Ponemos etiqueta al segundo eje y
# Limitamos los valores del eje x para que vayan desde -10 a 110
plt.xlim(-10,110)


Las funciones plt.axvline() y plt.axhline() dibujan líneas verticales y horizontales en la x o en la y que le digamos mientras que plt.axvspan y plt.axhspan dibujan recuadros entre las coordenadas x o y que queramos, respectivamente.

  • Ejemplo: 
    import numpy as np
import matplotlib.pyplot as plt

plt.ion() # Ponemos el modo interactivo
# Dibujamos un scatterplot de valores aleatorios
plt.scatter(np.random.randn(1000),np.random.randn(1000))
# Dibujamos una línea vertical verde centrada en x = -0.5
plt.axvline(-0.5, color = 'g')
# Dibujamos una línea vertical verde centrada en x = 0.5
plt.axvline(0.5, color = 'g')
# Dibujamos una línea horizontal verde centrada en x = -0.5
plt.axhline(-0.5, color = 'g')
# Dibujamos una línea horizontal verde centrada en x = 0.5
plt.axhline(0.5, color = 'g')
# Dibujamos un recuadro azul vertical entre x[-0.5,0.5]
# con transparencia 0.25
plt.axvspan(-0.5,0.5, alpha = 0.25)
# Dibujamos un recuadro azul horizontal entre x[-0.5,0.5]
# con transparencia 0.25
plt.axhspan(-0.5,0.5, alpha = 0.25)


El uso del texto dentro de las gráficas se muestra en el siguiente ejemplo:
  • Ejemplo: 
    plt.ion() # Ponemos modo interactivo
import matplotlib.pyplot as plt
import numpy as np
import calendar
# Para generar el lugar del primer días de cada mes en un año
dias = [np.array(calendar.mdays)[0:i].sum()+ 1 for i in
np.arange(12)+1]
# Creamos una lista con los nombres de los meses
meses = calendar.month_name[1:13]
plt.axes([0.1,0.2,0.8,0.65])
# Creamos un plot con 365 valores
plt.plot(np.arange(1,366), np.random.rand(365), label = 'valores al azar')
plt.xlim(-5,370) # Los valores del eje y variarán entre -5 y 370
plt.ylim(0,1.2) # Los valores del eje y variarán entre 0 y 1.2
plt.legend() # Creamos la caja con la leyenda
plt.title(u'Ejemplo de título') # Ponemos un título
# Ponemos un título superior
plt.suptitle(u'Ejemplo de título superior')
# Pedimos que se vean subrrayas de división en los ejes
plt.minorticks_on()
# Colocamos las etiquetas, meses, en las posiciones, días,
# con color azul y rotadas 45o
plt.xticks(dias, meses, size = 'small', color = 'b', rotation = 45)
plt.xlabel(u't (días)')
plt.ylabel('Media diaria')

Otros tipos de gráfico son plt.plot_date(), que es similar a plt.plot() considerando uno o ambos ejes como fechas, y plt.plotfile(), que dibuja directamente desde los datos de un fichero.
Otro tipo de gráfico sería el que podemos obtener con plt.stem(). Dibuja líneas
verticales desde una línea base.

  • Ejemplo: 
    plt.ion() # Nos ponemos en modo interactivo
x = np.arange(25) + 1 # Valores de x
y = np.random.rand(25) * 10. # Valores de y
# Valores de y normalizados. Esta nueva serie tiene media 0 y desvicación estándar 1
y_norm = (y - y.mean()) / y.std()
# Colocamos los límites del eje x
plt.xlim(np.min(x) - 1, np.max(x) + 1)
# Colocamos los límites del eje y
plt.ylim(np.min(y_norm)-1, np.max(y_norm)+1)
# Dibujamos los valores por encima de la media
plt.stem(x[y_norm > 0],y_norm[y_norm > 0],linefmt='k-.',markerfmt='go',basefmt='b-') 
# Dibujamos los valores por debajo de la media
plt.stem(x[y_norm < 0],y_norm[y_norm < 0],linefmt='k-.',markerfmt='ro',basefmt='b-') 
# Colocamos el título del gráfico
plt.title(u'Representación de (x, f(x))')
plt.xlabel('valores x') # Colocamos la etiqueta en el eje x
plt.ylabel('valores f(x)') # Colocamos la etiqueta en el eje y


  • Actividad: Comentar el siguiente código, diciendo en cada paso que es lo que hace. 
    plt.ion()
x = np.arange(100) 
y = np.random.rand(100) 
plt.plot(x,y, color = 'black', label = '(x, f(x)')
plt.plot(x[y > 0.9], y[y > 0.9],'bo', label = 'f(x) > 0.9')
plt.axhspan(0.9, 1, alpha = 0.1)
plt.ylim(0,1.2)
plt.legend()
plt.title(u'Parejas ordenadas (x, f(x))')
plt.xlabel('X')
plt.ylabel('f(x)')

SimilarSlides