Curso de introducción a la programación con Python¶

    Autor: Luis Fernando Apáez Álvarez
    -Curso PyM-
    Tarea 3: Librería matplotlib
    Fecha de Entrega: 12 de Agosto del 2022
    Solución

Descripción: En esta tarea utilizaremos lo aprendido en el último tema de la clase 3, donde vimos una introducción a la librería matplotlib. Además, veremos una breve introducción al concepto de listas en Python, lo cual nos servirá para poder realizar más gráficos utilizando Matplotlib

(Tiempo estimado: 50 minutos)

Listas¶

De manera intuitiva, podemos considerar el concepto de lista como una enumeración. Por ejemplo, cuando vamos al súper podemos crear una lista de las cosas que queremos comprar, digamos

  • Refrescos
  • Botanas
  • Leche
  • etcétera

De tal manera, la lista anterior se puede nombrar como lista del súper y sus elementos son productos, en este caso, alimenticios. Decimos de lo anterior que el elemento Refrescos de la lista ocupa la primer posición, que dentro de Python se le asigna el índice o lugar 0; las Botanas ocupan el segundo lugar de nuestra lista lista del súper, que Python le asigna el índice 0, y así sucesivamente. De manera totalmente análoga podemos definir una lista de números, digamos

lista de números: 1, 2, 3 ,4

donde, de nuevo, el primer elemento de la lista, el cual es el 1, Python le asigna la posición o índice 0 referente a dicha lista; también, podemos decir que el número 4 ocupa la posición número 3 de la lista.

Ahora bien, si queremos declarar una lista en Python ocuparemos corchetes, donde dentro de estos corchetes irán los elementos de la lista en cuestión separados por comas. Las listas en Python admiten datos de diferentes tipos, esto es, podemos definir una lista cuyos elementos sean de la clase int, u otros de la clase float, asimismo, podemos declarar que algunos de sus elementos sean cadenas de texto. Por ejemplo:

In [5]:
# declaramos nuestra lista del super
# los elementos de esta lista son solo cadenas de texto:
lista_super = ["Refrescos", "Botanas", "Leche"]

# vemos nuestra lista
print(lista_super)

# vemos de que tipo es la variable "lista_super"
print(type(lista_super))

['Refrescos', 'Botanas', 'Leche']
<class 'list'>

Podemos declarar también listas numéricas

In [1]:
# lista numerica
nums = [1, 2, 3, 4]
print(nums)
print(type(nums))

[1, 2, 3, 4]
<class 'list'>

Además, podemos acceder a cada uno de los elementos de las listas utilizando los índices que Python asigna. Por ejemplo, de la lista nums podemos acceder al primer elemento, el cual tiene asociado el índice 0, como sigue

In [6]:
# Accedemos al primer elemento de la la lista nums
# para ello colocamos el nombre de la lista
# seguido de dos corchetes, donde dentro de estos
# corchetes colocamos el índice del elemento
# al cual queremos acceder

print(nums[0])

1
In [19]:
# o alternativamente:
print(f"El primer elemento de la lista nums es: {nums[0]}, el cual tiene asociado el índice {0}")

print("-" * 80)
print(f"El primer elemento de la lista nums es: {nums[1]}, el cual tiene asociado el índice {1}")

print("-" * 80)
print(f"El primer elemento de la lista nums es: {nums[2]}, el cual tiene asociado el índice {2}")

print("-" * 80)
print(f"El primer elemento de la lista nums es: {nums[3]}, el cual tiene asociado el índice {3}")

El primer elemento de la lista nums es: 1, el cual tiene asociado el índice 0
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 2, el cual tiene asociado el índice 1
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 3, el cual tiene asociado el índice 2
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 4, el cual tiene asociado el índice 3
In [17]:
# o podemos ocupar tambien un bucle for:
for i in range(4):
    print(f"El primer elemento de la lista nums es: {nums[i]}, el cual tiene asociado el índice {i}")
    print("-" * 80)

El primer elemento de la lista nums es: 1, el cual tiene asociado el índice 0
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 2, el cual tiene asociado el índice 1
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 3, el cual tiene asociado el índice 2
--------------------------------------------------------------------------------
El primer elemento de la lista nums es: 4, el cual tiene asociado el índice 3
--------------------------------------------------------------------------------

Pero en realidad el mensaje arrojado es erróneo pues estamos mostrando la cadena El primer elemento repetidamente, cuando deberíamos mostrar un mensaje distinto en cada iteración. Para arreglar lo anterior ocuparemos una lista y modificaremos el código anterior como sigue:

In [4]:
# Creamos una lista auxiliar
au = ["primer", "segundo", "tercero", "cuarto"]

for i in range(4):
    # modificamos el f string
    print(f"El {au[i]} elemento de la lista nums es: {nums[i]}, el cual tiene asociado el índice {i}")
    print("-" * 80)

El primer elemento de la lista nums es: 1, el cual tiene asociado el índice 0
--------------------------------------------------------------------------------
El segundo elemento de la lista nums es: 2, el cual tiene asociado el índice 1
--------------------------------------------------------------------------------
El tercero elemento de la lista nums es: 3, el cual tiene asociado el índice 2
--------------------------------------------------------------------------------
El cuarto elemento de la lista nums es: 4, el cual tiene asociado el índice 3
--------------------------------------------------------------------------------

Con lo cual ya vemos que se imprime el mensaje correcto en cada iteración.

También podemos realizar lo mismo para la lista _listasuper

In [8]:
# cambiamos a range(3) pues dicha lista solo tiene 3 elementos
for i in range(3):
    print(f"El {au[i]} elemento de la lista súper es: {lista_super[i]}, con índice {i}")
    print("-" * 70)

El primer elemento de la lista súper es: Refrescos, con índice 0
----------------------------------------------------------------------
El segundo elemento de la lista súper es: Botanas, con índice 1
----------------------------------------------------------------------
El tercero elemento de la lista súper es: Leche, con índice 2
----------------------------------------------------------------------

Librería Matplotlib¶

Ahora sí podemos pasar a la actividad a realizar en esta tarea.

Instrucciones: Crearemos varios gráficos utilizando lo aprendido en la última parte de la clase 3, además de aprender algunas nuevas cosas respecto a los gráficos. Lo que deberás hacer es:

(1) Crea un gráfico mostrando cuatro puntos donde:

  • Deberás declarar el color de dichos puntos.
  • Deberás de utilizar diferentes marcadores o rotuladores (markers) para cada punto.
  • Cada gráfico correspondiente a los puntos tendrá una etiqueta.
  • Deberás colocar un título a tu gráfico, así como un título al eje $x$ y un título al eje $y$.
  • Deberás mostrar el gráfico y las etiquetas.

Para recordar los visto al final de la clase 3 puedes consultar el siguiente link: Clase 3

In [2]:
# Realizamos primer la importacion del modulo pyplot
import matplotlib.pyplot as plt

# Estos valores son arbitrarios
# tu pudiste haber elegido otros valores

# Direfentes rotuladores, diferentes colores
# Tu pudiste colocar una etiqueta diferente
plt.plot(1,2, marker="o", color="#DD2B05", label="Punto 1")
plt.plot(2,4, marker="*", color="#A78881", label="Punto 2")
plt.plot(3,0, marker="v", color="#00F489", label="Punto 3")
plt.plot(4,2, marker="8", color="#8A00F4", label="Punto 4")

# titulo
plt.title("Solución", fontsize=14)
# Etiquetas de los ejes
plt.xlabel("Eje x", fontsize=12)
plt.ylabel("Eje y", fontsize=12)

# mostramos las etiquetas (legendas)
plt.legend()

# mostramos el grafico
plt.show()

Para consultar más variedad de colores, así como su código hexagecimal, puedes consultar la siguiente página web Colores html

Gráfico de líneas¶

(2) Ahora utilizaremos lo aprendido sobre las listas. Dentro de la librería Matplotlib podemos crear un gráfico de líneas. El gráfico de líneas se genera a partir de la graficación de puntos (como ya lo vimos antes), salvo que en este caso, los puntos que se grafican serán unidos por una línea. Así, si queremos crear un gráfico de líneas debemos pasar en los parámetros de la función plt.plot() dos listas de números, en vez de pasar sólo los números individuales como lo hicimos antes. Por ejemplo

In [4]:
import matplotlib.pyplot as plt

# Creamos la primer lista, la cual corresponde a los valores de los 
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# Creamos la segunda lista, la cual corresponde a los valores de los 
# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)
plt.show()
In [5]:
# Creamos la primer lista, la cual corresponde a los valores de los 
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# Creamos la segunda lista, la cual corresponde a los valores de los 
# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# ---------------------------------------------------------------
# Agregamos la cuadricula
plt.grid()
# ---------------------------------------------------------------
plt.show()

(2.1) Tu labor es agregar una cuadrícula al gráfico anterior.

Ahora, podemos graficar cada uno de los puntos involucrados de manera individual como ya sabemos hacer:

In [6]:
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# Ahora graficamos los puntos individuales:
plt.plot(1, 1, marker="o")
plt.plot(2, 4, marker="o")
plt.plot(3, 9, marker="o")
plt.plot(4, 16, marker="o")

plt.show()
In [9]:
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# Ahora graficamos los puntos individuales:

# cambiamos los marcadores
plt.plot(1, 1, marker="v")
plt.plot(2, 4, marker="*")
plt.plot(3, 9, marker="x")
plt.plot(4, 16, marker="s")

# Agregamos una etiqueta  alos ejes
plt.xlabel("Eje x")
plt.ylabel("Eje y")

# agregamos una cuadricula
plt.grid()
plt.show()

(2.2) De nuevo, agrega una cuadrícula al gráfico anterior, asimismo, cambia el marcador o rotulador de cada uno de los puntos graficados. Colaca en el eje x la etiqueta "eje x" y en el eje y la etiqueta "eje y".

Podemos simplificar el código anterior si empleamos un bucle for y utilizando el acceso de los elementos de las listas mediante índices

In [11]:
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# Ahora graficamos los puntos individuales:
# implementando un bucle for
for i in range(4):
    plt.plot(nums_x[i], nums_y[i] , marker="o")
plt.show()

Puedes ver, por ejemplo, lo que ocurre en el for con el manejo de los índices

In [24]:
for i in range(4):
    print(f"Valor de la lista nums_x: {nums_x[i]} || Valor de la lista nums_y: {nums_y[i]}")

Valor de la lista nums_x: 1 || Valor de la lista nums_y: 1
Valor de la lista nums_x: 2 || Valor de la lista nums_y: 4
Valor de la lista nums_x: 3 || Valor de la lista nums_y: 9
Valor de la lista nums_x: 4 || Valor de la lista nums_y: 16

De la misma manera podemos agregar etiquetas a cada uno de los puntos

In [12]:
# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# Ahora graficamos los puntos individuales:
# implementando un bucle for
for i in range(4):
    plt.plot(nums_x[i], nums_y[i] , marker="o", label = f"({nums_x[i]},{nums_y[i]})")
    
# mostramos las etiquetas
plt.legend()
plt.show()
In [13]:
# Agregamos el estilo ggplot
plt.style.use("ggplot")

# puntos correspondientes al eje x
nums_x = [1, 2, 3, 4]

# puntos correspondientes al eje y
nums_y = [1, 4, 9, 16]

plt.plot(nums_x, nums_y)

# Ahora graficamos los puntos individuales:
# implementando un bucle for
for i in range(4):
    plt.plot(nums_x[i], nums_y[i] , marker="o", label = f"({nums_x[i]},{nums_y[i]})")
    
# mostramos las etiquetas
plt.legend()

# agregamos la cuadricula
plt.grid()
plt.plot()
Out[13]:
[]

(2.3) Agrega el estilo ggplot al gráfico anterior, así como una cuadrícula.

El gráfico de líneas suele utilizarse cuando es de nuestro interés analizar la relación entre un valor a los largo dle tiempo, lo que se conoce como serie de tiempo. Por ejemplo el precio de una acción en Apple:

Captura2222.PNG

Imagen extraída de Investing

se modela mediante series de tiempo. Podemos notar que básicamente el comportamiento del valor de dicha acción es visualiza como un gráfico de líneas.

Diagramas de dispersión¶

Los diagramas de dispersión nos sirven para buscar o visualizar posibles relaciones entre dos variables. Por ejemplo, podemos considerar ahora una lista de números que corresponda a la edad de ciertos niños, la cual llamaremos edad_nums; y consideraremos otra lista que corresponda a sus estaturas, la cual llamaremos altura_nums:

In [15]:
# puntos correspondientes las edades
edad_nums = [4, 4, 6, 8, 8, 5, 2, 7, 9]

# puntos correspondientes a las alturas
# correspondientes a cm
altura_nums = [100, 99.8, 112.9, 123.05, 124.4, 105.5, 85.5, 119.3, 127.7]

Es claro que dichos valores sí se relacionan pues la altura depende de la edad, al menos en los primeros 10 años de vida. Luego, podemos graficar dichos puntos, es decir los puntos de coordenadas $(edad, altura)$ en un diagrama de dispersión (scatter plot o también llamado diagrama de puntos) utilizando la función plt.scatter() como sigue

In [36]:
plt.scatter(edad_nums, altura_nums)
plt.show()
In [18]:
plt.scatter(edad_nums, altura_nums)
# agregamos un titulo
plt.title("Diagrama de dispersión", fontsize=14)

# agregamos etiquetas a los ejes
plt.xlabel("Edades")
plt.ylabel("Alturas")

# Agregamos una cuadricula:
# En este caso podemos notar que, si ocupamos el estilo ggplot
# y agregamos manualmente una cuadricula, entonces no se 
# muestra el cuadriculado. Lo que pasa es que el estilo 
# ggplot trae por defecto un cuadriculado, el cual no se muestra
# porque colocamos la instruccion plt.grid
# Asi, si queremos ver un cuadriculado no colocaremos 
# plt.grid()
#plt.grid()

plt.show()

Podemos ver que el comportamiento de los puntos sigue cierta tendencia lineal, lo cual nos está indicando que, justamente, los valores de la altura dependen de las edades de los niños, lo cual, repito, tiene mucho sentido pues mientras más edad tenemos, también más altura tenemos respecto a cuando somos niños.

(2.4) Agrega una cuadrícula al gráfico anterior, un título, así como etiquetas a los ejes.

Continuando, podemos graficar una recta que represente el comportamiento que siguen nuestros datos. Queda fuera del alcance de este curso ver el método que se lleva a cabo para hallar la ecuación de dicha recta que se acopla al comportamiento de los puntos, pues dicha teoría se abarca en un curso avanzado de Estadística y el tema en particular se denomina regresión lineal simple.

In [52]:
# definimos la funcion para graficar la recta
# que se acopla a nuestros datos
def f(x):
    return 5.54 * x + 77.84

# definimos un rango de valores para graficar
x = range(1,10)

# graficamos varios puntos correspondientes a la
# recta de acoplamiento, por el momento no le 
# prestes tanta atencion a lo que estamos 
# escribiendo, solo concentrate en el grafico
# resultante
plt.plot(x, [f(i) for i in range(1,10)], color="red", label="Recta de Ajuste")

# por otro lado graficamos de nuevo el scatter plot
plt.scatter(edad_nums, altura_nums, label="Diagrama de dispersión")

# mostramos las etiquetas
plt.legend()

# mostramos el grafico
plt.show()

El ejemplo anterior es uno muy sencillo, pero podemos escalar un poco en el grado de dificultad si agregamos más puntos al diagrama de dispersión, por ejemplo

In [37]:
# esta libreria la veremos en clases mas avanzadas
# por ahora no le prestes tanta atencion
import numpy as np

# de igual manera, por el momento no le 
# prestes tanta atencion a esto:
x = np.random.normal(5.0, 1.0, 1000)
y = np.random.normal(10.0, 2.0, 1000)

# lo importante es graficar y ver el diagrama de 
# dispersion que se crea
plt.scatter(x, y)
plt.show()