Universidad Nacional de San Agustín de Arequipa

Escuela Profesional de Ingeniería de Telecomunicaciones

Ingeniero Renzo Bolivar - Docente DAIE

Curso : Computación 2

PRÁCTICA 05
PYTHON - Librería Matplotlib

1.- Objetivos:
1. Presentación y/o Visualización de Datos con Matplotlib.

a. Utilizar datos en listas simples en Python para graficar con Matplotlib.

b. Utilizar datos en matrices NumPy para graficar con Matplotlib.

1. Seguir con buenas practicas en Python - Funciones y Excepciones.

2. Uso de entornos de desarrollo "Jupyter Python" y "Spyder".
3. Practica Colaborativa con sincronización con GitLab.

Nota: NO OLVIDAR INICIAR EL TRABAJO COLABORATIVO: en directorio: Practica_5 (con carpetas de Apellidos)

Primero:

JEFE DE PROYECTO: Inicia la practica Sincronizando repositorio local con proyecto GitLab.

(Ver Video: "Trabajo Colaborativo: Inicio Jefe de Proyecto").

Segundo:

COLABORADORES: Los colaboradores Clonan el proyecto de GitLab creado por el Jefe de Proyecto a
su repositorio local.

(Ver Video: "Trabajo Colaborativo: Inicio Colaboradores").

DESARROLLO

2.- Matplotlib

Matplotlib es una librería de trazado utilizada para gráficos 2D en lenguaje de programación Python, es muy flexible y tiene muchos
valores predeterminados incorporados que te ayudarán en tú trabajo. Para iniciar necesitas: - Realizar las importaciones necesarias
- Preparar algunos datos y - Trazar tu función con la ayuda de la interfaz pyplot.

Ingresamos al entorno de desarrollo Jupyter Notebook desde Anaconda Navigator.

Abrimos nuevo archivo lo llamamos Practica_05_matplotlib.ipynb (dentro de nuestra carpeta con nuestro Apellido).

Digitamos lo siguiente.

Instalación de Matplotlib: (recordamos como instalar librerías)

En la línea de comando de entorno Computacion2 digitar lo siguiente:

conda install ­c conda­forge matplotlib

Luego presionar Y para la instalación

Visualización con Matplotlib:

Importamos los paquetes necesarios:

In [1]: import numpy as np 
import matplotlib.pyplot as plt 

Interfaz pyplot:

Función plot

La interfaz pyplot proporciona una serie de funciones que operan sobre un estado global - es decir, nosotros no especificamos sobre
qué gráfica o ejes estamos actuando. Es una forma rápida y cómoda de crear gráficas pero perdemos parte del control.

El paquete pyplot se suele importar bajo el alias plt , de modo que todas las funciones se acceden a través de plt.<funcion> .
La función más básica es la función plot :

In [2]: #Preparamos algunos datos creando listas 
y = [1, 2, 5, 10] 
 
#Graficamos 
plt.plot(y) 
#plt.plot﴾y,   'g­­d'﴿ 
plt.show()       #imprime la grafica 

La función plot recibe una sola lista (si queremos especificar los valores y) o dos listas (si especificamos x e y). Naturalmente si
especificamos dos listas ambas tienen que tener la misma longitud.

Gráficas de línea
In [3]: #Preparamos algunos datos creando listas 
x = [0.0, 0.1, 0.2, 0.7, 0.9] 
y = [1, ­2, 3, 4, 1] 
 
#Graficamos 
plt.plot(x, y) 
plt.grid()     #grilla 
plt.show() 

In [4]: #Preparamos algunos datos creando listas 
x = [0, 0.1, 0.2, 0.5,0.6] 
y = [1, ­1, 0, 3, ­1] 
 
#Graficamos 
plt.plot(x, y, color='blue', linewidth=2, label='Linea') 
plt.legend()       #leyenda 
plt.grid()         
plt.show() 

In [5]: #Definir los datos 
x1 = [3, 4, 5, 6] 
y1 = [5, 6, 3, 4] 
x2 = [2, 5, 8] 
y2 = [3, 4, 3] 
 
#Configurar las características del gráfico 
plt.plot(x1, y1, label = 'Línea 1', linewidth = 4, color = 'blue') 
plt.plot(x2, y2, label = 'Línea 2', linewidth = 4, color = 'green') 
 
#Definir título y nombres de ejes 
plt.title('Diagrama de Líneas')           #titulo principal 
plt.ylabel('Eje Y')                       #nombre eje Y 
plt.xlabel('Eje X')                     #nombre eje X 
 
#Mostrar leyenda, cuadrícula y figura 
plt.legend() 
plt.grid() 
plt.show() 

Grafico de Barras

Los gráficos de barras se usan para comparar datos entre diferentes categorías, estos se pueden representar horizontal o verticalmente.

La pogramación es muy parecida con gráficas de líneas, definimos los datos que vamos a graficar y configuramos las características del
gráfico, en ves de utilizar plt.plot() usamos plt.bar() que indica que se va a graficar una gráfica de barras. El resto de
instrucciones es exactamente igual.

Barras Verticales

In [6]: # Definir los datosDefinir los datos 
fechas = ['15/05/2020', '18/05/2020', '20/05/2020', '22/05/2020', '25/05/2020'] #eje X 
valores = [42, 83, 68, 90, 80]                                                  #eje Y 
 
#caracteristicas de gráfico 
plt.bar(range(5), valores, edgecolor='black') #las barras contorno 
plt.xticks(range(5), fechas)                 # Nombre eje X 
plt.ylim(min(valores)­10, max(valores)+10)      #limites de Y 
 
#Titulo y Nombre de Ejes 
plt.title('Farmacia ­ Ingresos por Día')      #titulo 
plt.ylabel('Soles') 
plt.xlabel('Fechas') 
 
plt.show() 

Barras Horizontales

In [7]: # Definir los datos 
fechas = ['15/05/2020', '18/05/2020', '20/05/2020', '22/05/2020', '25/05/2020'] #eje X 
valores = [42, 83, 68, 90, 80]                                                  #eje Y 
 
#Configurar Grafico 
plt.barh(range(5), valores, edgecolor='black') 
plt.yticks(range(5), fechas, rotation=60)       # Nombre eje Y 
plt.xlim(min(valores)­10, max(valores)+10)       #limites de X 
 
#Titulo y Nombre de Ejes 
plt.title('Farmacia ­ Ingresos por Día')      #titulo 
plt.ylabel('Fechas') 
plt.xlabel('Soles') 
 
plt.show() 

Gráfica Circular (pastel)

Un gráfico circular se divide en segmentos, es decir, sectores de pastel, básicamente se usa para mostrar el porcentaje o los datos
proporcionales en los que cada porción del pastel representa una categoría.

El procedimiento es muy parecido alos casos anteriores, ahora se utiliza plt.pie() pero se debe especificar otras características para
mejorar la presentación de la gráfica.

Simple

In [8]: # Definir los datos 
manzanas = [20,10,25,30] 
nombres = ["Ana", "Juan", "Diana", "Catalina"] 
 
#caracteristicas de gráfico 
plt.pie(manzanas, labels=nombres) 
 
#Definir título 
plt.title('Gráfico Circular') 
plt.show() 

Con porcentajes

In [9]: # Definir los datos 
manzanas = [20,10,25,30] 
nombres = ["Ana", "Juan", "Diana", "Catalina"] 
 
#caracteristicas de gráfico 
plt.pie(manzanas, labels=nombres, autopct='%0.1f %%') 
 
#Definir título 
plt.title('Gráfico Porcentajes') 
plt.show() 

Cambio de colores

In [10]: # Definir los datos 
manzanas = [20,10,25,30] 
nombres = ["Ana", "Juan", "Diana", "Catalina"] 
 
#lista de colores 
colores = ['magenta','green','red','cyan'] 
 
#caracteristicas de gráfico 
plt.pie(manzanas, labels=nombres, autopct='%0.1f %%', colors=colores) 
 
#Definir título 
plt.title('Gráfico Colores') 
plt.show() 

Separación del pie

In [11]: # Definir los datos 
manzanas = [20,10,25,30] 
nombres = ["Ana", "Juan", "Diana", "Catalina"] 
 
#lista de colores 
colores = ['magenta','green','red','cyan'] 
desface = (0,0,0,0.1)   #desface 
 
#caracteristicas de gráfico 
plt.pie(manzanas, labels=nombres, autopct='%0.1f %%', colors=colores, explode=desface) 
 
#Definir título 
plt.title('Gráfico Separado') 
plt.show() 

Gráfica Dispersión

Los gráficos de dispersión se utilizaron para comparar variables, por ejemplo, cuánto una variable se ve afectada por otra variable y de
esta forma se construye una relación a partir de ella.

En esta gráfica los datos se muestran como una colección de puntos, cada uno con el valor de una variable que determina la posición en
el eje horizontal y el valor de otra variable determina la posición en el eje vertical.

La gráfica se construye utilizando el comando plt.scatter() que significa dispersión en inglés, y el resto de las instrucciones son las
mismas que hemos utilizado hasta ahora.

Simple

In [12]: # Definir los datos 
x = np.random.randint(1,100, size=20) 
y = np.random.randint(50,200, size=20) 
 
#caracteristicas de gráfico 
plt.scatter(x,y) 
plt.title('Gráfico Dispersión') 
plt.show() 

Histogramas

Los histogramas se usan para mostrar una distribución, son útiles cuando tienes matrices o una lista muy larga. Veamos como podemos
graficar este tipo de gráficos.

Para esta gráfica definimos los datos y a su vez un los bins que vendría siendo los compartimientos en donde estarán ubicados en
nuestra gráfica los datos. A su vez acá empleamos la instrucción plt.hist() para representar esta gráfica y el resto de instrucciones
es la misma que hemos utilizado con anterioridad.

simple

In [13]: #Definir los datos 
a = [22,55,62,45,21,22,34,42,42,4,2,102,95,85,55,110,120,70,65,55,111,115,80,75,65,54,44,43,42,48] 
bins = [0,10,20,30,40,50,60,70,80,90,100] 
 
#Configurar las características del gráfico 
plt.hist(a, bins, histtype = 'bar', rwidth = 0.8, color = 'lightgreen') 
 
#Definir título y nombres de ejes 
plt.title('Histograma') 
plt.ylabel('Eje Y') 
plt.xlabel('Eje X') 
 
#Mostrar figura 
plt.show() 

EJEMPLOS:

Ejemplo 1: Varias gráficas de línea

In [14]: #declaramos el tamaño de la figura 
fig = plt.figure(figsize=(15,15)) 
fig.tight_layout()  #definimos espaciado suficiente entre graficas 
 
#lista de colores 
colores = ['blue','green','red','cyan','magenta','yellow','black','white'] 
 
for i in range(1,7):                 # seis graficas 
    x = np.arange(0,16,2)            # rango de numeros desde 0 al 16 , de 2 en 2 
    y = pow(x,np.random.randint(0,6))+np.random.randint(0,10)*x+np.random.randint(­5,10) # ecuación al
 azar con x elevado a la potencia al azar de 0 a 6,  
    ax = plt.subplot(2,3,i)          # acomodo de 2 filas con 3 columnas acomodo con i 
    ax.plot(x,y,color = colores[i])  #graficamos con color cada subgrafica 
    ax.set_xlabel('x')            #etiquetas 
    ax.set_ylabel('y') 
    ax.set_title('Gráfica '+str(i)) 
     

Ejemplo 2: Gráfica completa circular

In [15]: #Definir los datos 
dormir =[7,8,6,11,7] 
comer = [2,3,4,3,2] 
trabajar =[7,8,7,2,2] 
recreación = [8,5,7,8,13] 
divisiones = [7,2,2,13] 
actividades = ['Dormir','Comer','Trabajar','Recreación'] 
colores = ['red','purple','blue','orange'] 
desfase = (0.1,0,0,0) 
 
#Configurar las características del gráfico 
plt.pie(divisiones, labels=actividades, colors=colores, startangle=90, shadow=True, explode=desfase, au
topct='%1.1f%%') 
 
#Definir título 
plt.title('Gráfico circular') 
 
#Mostrar figura 
plt.show() 

Ejemplo 3: Barras Dobles Verticales

In [16]: #Definir los datos 
x1 = [0.25, 1.25, 2.25, 3.25, 4.25] 
y1 = [10, 55, 80, 32, 40] 
x2 = [0.75, 1.75, 2.75, 3.75, 4.75] 
y2 = [42, 26, 10, 29, 66] 
 
#Configurar las características del gráfico 
plt.bar(x1, y1, label = 'Datos 1', width = 0.5, color = 'lightblue', edgecolor='black') 
plt.bar(x2, y2, label = 'Datos 2', width = 0.5, color = 'orange', edgecolor='black') 
 
#Definir título y nombres de ejes 
plt.title('Gráfico de barras') 
plt.ylabel('Eje Y') 
plt.xlabel('Eje X') 
 
#Mostrar leyenda y figura 
plt.legend() 
plt.show() 

Ejemplo 4: Gráfico Dispersión

In [17]: #Definir los datos 
x1 = [0.25, 1.25, 2.25, 3.25, 4.25] 
y1 = [10, 55, 80, 32, 40] 
x2 = [0.75, 1.75, 2.75, 3.75, 4.75] 
y2 = [42, 26, 10, 29, 66] 
 
#Configurar las características del gráfico 
plt.scatter(x1, y1, label = 'Datos 1',color = 'red') 
plt.scatter(x2, y2,label = 'Datos 2', color = 'purple') 
 
#Definir título y nombres de ejes 
plt.title('Gráfico de dispersión') 
plt.ylabel('Eje Y') 
plt.xlabel('Eje X') 
 
#Mostrar leyenda y figura 
plt.legend() 
plt.show() 

Ingresamos al entorno de desarrollo Spyder desde Anaconda Navigator.

Abrimos nuevo archivo con el nombre: Practica_05_matplotlib.py (dentro de nuestra carpeta con nuestro Apellido).

Digitamos todas las lineas anteriores y luego ejecutamos para verificar que esta correcto, al final guardamos.

Ejercicios Matemáticos:

Ingresamos al entorno de desarrollo Spyder desde Anaconda Navigator y/o Terminal entorno computacion2.

Creamos 03 nuevos archivos con nombres: (dentro de nuestra carpeta con nuestro Apellido).

  ­ `Ejercicio_01_matplotlib.py` 
  ­ `Ejercicio_02_matplotlib.py` 
  ­ `Ejercicio_03_matplotlib.py` 
  ­ `Ejercicio_04_matplotlib.py` 
  ­ `Ejercicio_05_matplotlib.py`

Digitamos solución de cada Ejercicio y luego ejecutamos para verificar que esta correcto, al final guardamos.

Ejercicio 1

La tarea más habitual a la hora de trabajar con matplotlib es representar una función. Lo que tendremos que hacer es definir un dominio y
evaluarla en dicho dominio. Por ejemplo:

2
−
( ) =

In [18]: def f(x): 
    return np.exp(­x ** 2) 

Definimos el dominio con la función np.linspace , que crea un vector de puntos equiespaciados:

In [19]: x = np.linspace(­1, 3, 100) 

Y representamos la función:
In [20]: plt.plot(x, f(x), label="Función f(x)") 
plt.xlabel("Eje $x$") 
plt.ylabel("$f(x)$") 
plt.legend() 
plt.title("Función $f(x)$") 
plt.show() 

Notamos varias cosas:

Con diversas llamadas a funciones dentro de plt. se actualiza el gráfico actual. Esa es la forma de trabajar con la interfaz pyplot.
Podemos añadir etiquetas, y escribir en ellas. Tan solo hay que encerrarlo entre signos de dólar $$.
Añadiendo como argumento label podemos definir una leyenda.

Ejercicio 2:

La función plot acepta una serie de argumentos para personalizar el aspecto de la función. Con una letra podemos especificar el color,
y con un símbolo el tipo de línea.

In [21]: plt.plot(x, f(x), 'ro') 
plt.plot(x, 1 ­ f(x), 'g­­') 
plt.show() 

Esto en realidad son códigos abreviados, que se corresponden con argumentos de la función plot :

In [22]: plt.plot(x, f(x), color='red', linestyle='', marker='o') 
plt.plot(x, 1 ­ f(x), c='g', ls='­­') 
plt.show() 

La lista de posibles argumentos y abreviaturas está disponible en la documentación de la función plot

http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot.

Ejercicio 3:

La función scatter muestra una nube de puntos, con posibilidad de variar también el tamaño y el color.

In [23]: N = 100 
x = np.random.randn(N) 
y = np.random.randn(N) 
 
plt.scatter(x, y) 
plt.show() 

Con s y c podemos modificar el tamaño y el color respectivamente. Para el color, a cada valor numérico se le asigna un color a través
de un mapa de colores; ese mapa se puede cambiar con el argumento cmap . Esa correspondencia se puede visualizar llamando a la
función colorbar .

In [24]: s = np.abs(50 + 50 * np.random.randn(N)) 
c = np.random.randn(N) 
 
plt.scatter(x, y, s=s, c=c, cmap=plt.cm.Blues) 
plt.colorbar() 
plt.show() 

In [25]: plt.scatter(x, y, s=s, c=c, cmap=plt.cm.Oranges) 
plt.colorbar() 
plt.show() 

Ejercicio 4:

Podemos crear figuras con varios sistemas de ejes, pasando a subplot el número de filas y de columnas.

In [26]: x = np.linspace(­1, 7, 1000) 
 
fig = plt.figure() 
plt.subplot(211) 
plt.plot(x, np.sin(x)) 
plt.grid(False) 
plt.title("Función seno") 
 
plt.subplot(212) 
plt.plot(x, np.cos(x)) 
plt.grid(False) 
plt.title("Función coseno") 
 
plt.show() 

¿Cómo se ajusta el espacio entre gráficas para que no se solapen los textos? Buscamos en Google "plt.subplot adjust" en el primer
resultado tenemos la respuesta http://stackoverflow.com/a/9827848

Como hemos guardado la figura en una variable, puedo recuperarla más adelate y seguir editándola.

In [27]: fig.tight_layout() 
fig 

Out[27]:

Si queremos manipular la figura una vez hemos abandonado la celda donde la hemos definido, tendríamos que utilizar la interfaz
orientada a objetos de matplotlib. Es un poco lioso porque algunas funciones cambian de nombre, así que en este curso no la vamos
a ver. Si te interesa puedes ver los notebooks de la primera edición, donde sí la introdujimos.
https://github.com/AeroPython/Curso_AeroPython/releases/tag/v1.0

Ejercicio 5:

Crear una función que represente gráficamente esta expresión:

sin(2 1
) + sin(2 2
)

Siendo 1
y 2
argumentos de entrada (por defecto 10 y 100) y ∈ [0, 0.5] . Además, debe mostrar:

leyenda,
título "Dos frecuencias",
eje x "Tiempo ( )"

y usar algún estilo de los disponibles.

In [28]: def frecuencias(f1=10.0, f2=100.0): 
    max_time = 0.5 
    times = np.linspace(0, max_time, 1000) 
    signal = np.sin(2 * np.pi * f1 * times) + np.sin(2 * np.pi * f2 * times) 
    with plt.style.context("ggplot"): 
        plt.plot(signal, label="Señal") 
        plt.xlabel("Tiempo ($t$)") 
        plt.title("Dos frecuencias") 
        plt.legend() 
 
frecuencias() 

3.- Sincronizar cuanta veces sea necesario los cambios con git:

Ingresamos a la linea de comando.

En nuestro directorio de Practica_05 .

Añadimos los cambios de archivos a git:

(Programacion2) renzo@misti:~$ git add ­A 
 
(Programacion2) renzo@misti:~$ git commit ­m "Finalizando Practica 02" 

Actualizamos nuestros repositorio local con los cambios del respositorio de GitLab:

(Programacion2) renzo@misti:~$ git pull origin master 

Enviamos nuestros cambios al repositorio remoto de GitLab:

(Programacion2) renzo@misti:~$ git push origin master 

Si se hace cambios repetir los pasos anteriores de comandos git.

Para tener evidencia del trabajo realizado envía un solo integrante al Aula Virtual, la carpeta con todo el proyecto en zip.

Finaliza la Práctica

Bibliografía

[1] Guía de matplotlib para principiantes http://matplotlib.org/users/beginner.html

[2] Tutorial de matplotlib en español http://pybonacci.org/tag/tutorial-matplotlib-pyplot/

[3] Referencia rápida de matplotlib https://scipy-lectures.org/intro/matplotlib/index.html