Procesamiento de datos y visualización con Python

I. Introducción y objetivos

II. Matplotlib

III. Ggplot

IV. Seaborn

V. Bokeh

VII. Resumen

VI. Caso práctico con solución

VII. Enlaces de interés

VIII. Glosario

IX. Bibliografía
Lección 1 de 10

I. Introducción y objetivos

1.1. Introducción de la unidad

La visualización de datos nos permite mostrar la información con objeto de comunicar unos determinados resultados. A lo largo de este módulo veremos los
principales paquetes de Python para realizar visualización de datos y, por supuesto, seguiremos trabajando con datos a través de las diferentes estructuras de
datos que ya hemos conocido en las unidades anteriores.

Se realizarán diferentes estilos de gráficas (diagrama de dispersión, de densidad, gráfico de barras, histograma, diagrama de caja y bigotes, etc.) se aprenderá a
modificar los diferentes elementos de una gráfica, modificar los valores de sus ejes  y añadir texto sobre los mismos, incluido el título. 

Se comprenderá cómo se pueden utilizar diferentes tipos de estructuras de datos para ser representadas a través de una visualización. 

El alumno aprenderá a utilizar diferentes tipos de color para representar los valores de una gráfica, en función del paquete que estemos empleando, incluso, se
podrá utilizar color para una gráfica a través de variables categóricas o valores únicos de variables numéricas.

C O NT I NU A R
 1. 2. Objetivos de la unidad

Al término de esta unidad el alumno habrá adquirido las siguientes competencias.

1 Realizar y distinguir entre los principales gráficos (nube de puntos, gráfico lineal, gráfico de barras, histograma, etc.).

2 Procesar , dataframes, listas, arrays, diccionarios de datos y tuplas para su posterior visualización.

3 Visualizar gráficos a través de la librería Matplotlib.

4 Visualizar gráficos de capas a través de la librería Ggplot.

5 Visualizar gráficos de tipo estadístico  a través de la librería Seaborn.

6 Saber implementar gráficos dinámicos a través de la librería Bokeh

Lección 2 de 10

II. Matplotlib

Matplotlib1 es una librería para la creación de gráficos estáticos estadísticos o animados en Python. Nos permite configurar customizar prácticamente cualquier
elemento de una visualización de datos.

En Matplotlib, todo el desarrollo gráfico se realizará a través de la interfaz de Pyplot. La visualización se desarrolla de forma secuencial, es decir: cada comando de
Pyplot genera una modificación en la gráfica que estemos realizando.

Al igual que muchas librerías de Python, Pyplot es comúnmente utilizada bajo un alias “plt”. Para comenzar a trabajar con Matplotlib y Pyplot, se importa la librería.

 NOTA: se recomienda seguir todo el contenido junto con el siguiente notebook disponible para su descarga:

MATPLOTLIB.ipynb.zip
266.3 KB

MATPLOTLIB.html.zip
312.2 KB

import matplotlib.pyplot as plt

–
import matplotlib.pyplot as plt
Generamos una lista para crear nuestra primera visualización.

lista = [1, 5, 10, 15, 20, 25, 30]

–
lista = [1, 5, 10, 15, 20, 25, 30]

El comando más básico que permite realizar gráficas con Pyplot es plot; por lo tanto, si se ejecuta el siguiente comando, aparecerá como resultado una gráfica. Por defecto, esta
será lineal.
plt.plot
–
plt.plot(lista)

Se puede observar que, simplemente, se muestra cada valor de índice con su valor correspondiente al valor de la lista. Pueden agregarse algunos elementos de estilo, como
etiquetas al eje “y” y al eje “x”. Para ello, se añadirá un nuevo componente con “ylabel” o “xlabel”.

Figura 1. Primera visualización de datos con Matplotlib.

Fuente: elaboración propia.

plt.ylabel plt.xlabel
–
plt.ylabel('Valores de la lista')  plt.xlabel('Valores de índice')

Como se puede comprobar, no aparece nada de la lista anterior. Para que Pyplot tome en cuenta todos los elementos que se agregan a una gráfica y los muestre correctamente por
pantalla, hay que definir dónde acaba la gráfica con la función show. Se recomienda siempre realizar toda la visualización de forma conjunta, es decir: en la misma celda de código.

Figura 2. Agregar elementos de texto en ejes “x” e “y”.

Fuente: elaboración propia.

plt.plot plt.ylabel plt.xlabel plt.show

–
plt.plot(lista)  
plt.ylabel('Valores de la lista')  
plt.xlabel('Valores de índice')  
plt.show()

Una vez se tienen los conocimientos para imprimir algo básico, como una lista con su propio índice, se realizará una modificación y, en lugar de mostrar el índice en el eje “x”, se
mostrará otra lista con valores diferentes.

Figura 3.. Gráfica lineal y elementos de texto.

Fuente: elaboración propia

lista_2 = [4, 5, 8, 3, 15, 12, 9] plt.plot plt.ylabel plt.xlabel plt.show

–
lista_2 = [4, 5, 8, 3, 15, 12, 9]
 
plt.plot(lista, lista_2)
plt.ylabel('Valores de la lista')
plt.xlabel('Valores de índice')
plt.show()

Figura 4. Gráfica lineal, dos componentes.

Fuente: elaboración propia.
 1Web de Matplotlib URL disponible en el siguiente enlace. 

C O NT I NU A R

En vista de esta nueva gráfica, es importante resaltar algo:

El eje de abscisas “x” toma el valor del primer parámetro (en su ausencia, será el índice de la lista).

El eje de ordenadas “y” toma el valor del segundo parámetro.

 En algunas ocasiones, podemos necesitar unos ejes más amplios o reducidos para nuestras gráficas. Para ello, se puede realizar una nueva lista que contenga
cuatro valores:

Eje de inicio “x”.

Eje de fin “x”.

Eje de inicio “y”.

Eje de fin “y”.

 Estos valores se pasarán al parámetro axis.

lista_eje = [0, 40, 0, 20]

plt.plot(lista, lista_2)
plt.axis(lista_eje)
plt.ylabel('Valores de la lista')
plt.xlabel('Valores de índice')
plt.show()
 Figura 5. Gráfica lineal, nuevos ejes.
Fuente: elaboración propia.

Como resultado, se puede observar que los índices se han agrandado tanto por el eje “x” y el eje “y”. Esto provoca que nuestra gráfica no se ajuste perfectamente
en el marco destinado a su visualización.
 1

Definir el color

Figura 6. Gráfica lineal, cambio de color (I).

Fuente: elaboración propia.

plt.plot(lista, lista_2, color='green')

plt.ylabel('Valores de ala lista')

plt.xlabel('Valores de índice')

plt.show()

Finalmente, sobre la primera gráfica, se puede decidir cambiar el color. Esto se realiza con el parámetro plot. Tras los argumentos de
entrada de los ejes “x” e “y”, podemos definir el color a través del parámetro color.
 2

Cambiar el color

Figura 7. Gráfica lineal, cambio de color (II). 

Fuente: elaboración propia.

plt.plot(lista, lista_2, color='gold')

plt.ylabel('Valores de ala lista')

plt.xlabel('Valores de índice')

plt.show()

Se puede encontrar una lista de colores que podemos utilizar en el siguiente enlace. 
 3

Figura 8. Agregar título.

Fuente: elaboración propia.

plt.plot(lista, lista_2, color='red')

plt.title('Mi título')

plt.ylabel('Valores de ala lista')

plt.xlabel('Valores de índice')

plt.show()

Otra función de interés es la de agregar título a una gráfica. Se realiza con title:

En estos primeros ejemplos, se ha visto cómo jugar con la amplitud de ejes y mostrar dos listas. Sin embargo, es habitual que se superpongan diferentes variables
en una misma gráfica.

C O NT I NU A R

Superponer diferentes variables

R E PR E S E N TA R O T R O S
A Ñ A DI R E LE M E N T O S A Ñ A DI R UN A LE Y E N DA DE S A PA R I C I Ó N DE LÍ N E A S
E LE M E N T O S
 El proceso es el mismo, es decir, tenemos que ir añadiendo elementos con plot. Para este ejemplo, utilizaremos Numpy arrays, por lo tanto, importamos
su librería y generamos nuevos valores.

import numpy as np
 
valores = np.linspace(0, 2, 100)
 
plt.plot(valores)
plt.plot(valores**2)
plt.plot(valores**3)
 
plt.xlabel('Ítem')
plt.ylabel('Valor')
 
plt.title("Transformación de una varaible")
 
plt.show()

Figura 9. Añadir más de un elemento a la gráfica.

Fuente: elaboración propia.

R E PR E S E N TA R O T R O S
A Ñ A DI R E LE M E N T O S A Ñ A DI R UN A LE Y E N DA DE S A PA R I C I Ó N DE LÍ N E A S
E LE M E N T O S

Cuando se añade más de una variable a la gráfica, automáticamente se define el color y la amplitud de los ejes “x” e “y”. En estos casos, es interesante
añadir una leyenda a nuestra gráfica. Para hacerlo, hay que utilizar la función “legend()”, pero, en cada elemento plot, hay que utilizar el parámetro label
para añadir el texto que aparecerá en la leyenda de nuestra gráfica.

plt.plot(valores, color = 'red', label = 'Lineal')

plt.plot(valores**2, color = 'blue', label = 'Cuadrática')
plt.plot(valores**3, color = 'green', label = 'Cúbica')
 
plt.xlabel('Ítem')
plt.ylabel('Valor')
plt.title("Transformación de una varaible")
plt.legend()
 
plt.show()
 Figura 10. Añadir leyenda a una gráfica.
Fuente: elaboración propia.

R E PR E S E N TA R O T R O S
A Ñ A DI R E LE M E N T O S A Ñ A DI R UN A LE Y E N DA DE S A PA R I C I Ó N DE LÍ N E A S
E LE M E N T O S

No solamente se pueden utilizar líneas como formas para representar nuestras gráficas, sino que existen otro tipo de elementos que se pueden
representar. Puede consultarse una lista completa de estos elementos en el siguiente enlace. 

plt.plot(valores, color = 'red', label = 'Lineal', marker='.') 

plt.plot(valores**2, color = 'blue', label = 'Cuadrática', marker = '^' )
plt.plot(valores**3, color = 'green', label = 'Cúbica', marker='s')
 
plt.xlabel('Ítem')
plt.ylabel('Valor')
plt.title("Transformación de una varaible")
plt.legend()
 
plt.show()

Figura 11. Nuevos marcadores lineales.

Fuente: elaboración propia.
 R E PR E S E N TA R O T R O S
A Ñ A DI R E LE M E N T O S A Ñ A DI R UN A LE Y E N DA DE S A PA R I C I Ó N DE LÍ N E A S
E LE M E N T O S

Si deseamos que desaparezcan las líneas completamente, hay que añadir directamente el argumento sin markers.

t = np.arange(0., 5., 0.2)

 
plt.plot(t, t, '--')
plt.plot(t, t**2, 's')
plt.plot(t, t**3, '^')
plt.show()

Figura 12. Nuevos marcadores.

Fuente: elaboración propia.
 C O NT I NU A R

Mediante Pyplot, también se puede añadir en un mismo espacio gráfico más de una visualización. Para ello, existe la importante función subplot, que recibe los
siguientes parámetros:

Número de filas.

Número de columnas.

Índice (posición).

Ejemplo

A continuación, se muestra un ejemplo de dos gráficas (por lo tanto, dos filas, una columna y hasta dos gráficas):

Figura 13. Subplots.

Fuente: elaboración propia.

def balance(t):
return np.exp(-t) * np.cos(2*np.pi*t)
my_array_one = np.arange(0.0, 5.0, 0.1)
my_array_dos = np.arange(0.0, 5.0, 0.02)

plt.subplot(211)
plt.plot(my_array_one, balance(my_array_one), 'bo')
plt.plot(my_array_dos, balance(my_array_dos), 'k')

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

C O NT I NU A R

LA F UN C I Ó N T E X T

Antes de pasar a diferentes tipos de gráficas, se muestra cómo añadir texto en el interior de una visualización. La función text, seguida de la posición “x”
e “y” donde irá el elemento, permitirá añadir texto dentro de una visualización. Se muestra la gráfica anterior como ejemplo.

plt.plot(valores, color = 'red', label = 'Lineal')

plt.plot(valores**2, color = 'blue', label = 'Cuadrática')
plt.plot(valores**3, color = 'green', label = 'Cúbica')
 
plt.text(80, 5, 'Transformada cúbica')
plt.xlabel('Ítem')
plt.ylabel('Valor')
plt.title("Transformación de una varaible")
plt.legend()
 
plt.show()

Figura 14. Texto dentro de una gráfica (I).

Fuente: elaboración propia.
Es importante tener cuidado con las posiciones de los ejes, ya que puede distorsionar el diseño de la gráfica. En el caso de que sucediera, habría que redistribuir las posiciones
del texto en los ejes “x” e “y”, como se ve en la figura 14.

plt.plot(valores, color = 'red', label = 'Lineal')

plt.plot(valores**2, color = 'blue', label = 'Cuadrática')
plt.plot(valores**3, color = 'green', label = 'Cúbica')
 
plt.text(45, 5, 'Transformada cúbica')
plt.text(60, 0.8, 'Original')
plt.text(80, 1.3, 'Cuadrática')
 
plt.xlabel('Ítem')
plt.ylabel('Valor')
plt.title("Transformación de una varaible")
plt.legend()
 
plt.show()

Figura 15. Texto dentro de una gráfica (II).

Fuente: elaboración propia.

 C O NT I NU A R

Una vez vistos los elementos principales para diseñar una visualización de datos con Matplotlib, se muestran algunos ejemplos diferentes a una gráfica lineal.

1 Histograma

Un histograma es una visualización de datos en la que una variable se representa a través de barras y donde la superficie de cada barra es
proporcional a la frecuencia de los valores representados.  

Para representar un ejemplo de histograma replicaremos la curva de una distribución normal, por lo tanto, definiremos previamente un valor
para la media (mu) y la desviación típica (sd).

Figura 16. Histograma.

Fuente: elaboración propia.
 mu = 150 # Media de la distribución
sigma = 15 # Desviación estandar de la distribución
x = mu + sigma * np.random.randn(1000) # Distribución normal de 1000 elementos

num_bins = 100

# Mostramos valores
n, bins, patches = plt.hist(x, num_bins, density=1, color='lightgreen')

# Distribución normal
y = ((1 / (np.sqrt(2 * np.pi) * sigma)) *
np.exp(-0.5 * (1 / sigma * (bins - mu))**2))

plt.plot(bins, y, 'b--')
plt.xlabel('Frecuencia')
plt.ylabel('Valor')

plt.show()

C O NT I NU A R

2 Diagramas

Diagrama de barras 1
–
Muestra el valor de una variable en forma de barra vertical u horizontal. Para mostrar el diagrama de barras, se generará artificialmente una serie de fechas y dos arrays para
simular un dataframe.
 
import pandas as pd
fechas = pd.date_range('20200101',periods=12)
 
air_quality = pd.DataFrame(np.random.randint(10, 50, 24).reshape(12,2), 
                      index=fechas, 
                      columns = ["AQI Madrid", "AQI Barcelona"])

Figura 17. Dataframe para diagrama de barras.

Fuente: elaboración propia.
Diagrama de barras 2
–
air_quality.plot(kind="barh", title="Air Quality Index")

Figura 18. Diagrama de barras.

Fuente: elaboración propia.

Diagrama de barras 3
–
Si se añade el parámetro subplots, el dataframe se dividirá por la agrupación de los diferentes arrays.
 
air_quality.plot(kind="barh", subplots=True)

Figura 19. Diagrama de barras agrupado.

Fuente: elaboración propia.
Diagrama de barras. Ejemplo con listas
–
Se muestra otro ejemplo, en este caso, con listas:
 
# Datos sobre temperatura
temp_max = [35, 38, 29, 27]
temp_min = [23, 22, 21, 18]
n_groups = len(temp_max)
 
index = np.arange(n_groups)
 
max_ = plt.bar(index, temp_max, color='tomato', 
                  label='T. Max')
 
min_ = plt.bar(index , temp_min, color='lightgreen', 
                  label='T. Min')
 
plt.xlabel('Ciudades')
plt.ylabel('Temperaturas')
plt.title('Temperatura por ciudad')
plt.xticks(index , ('Madrid', 'Barcelona', 'Asturias', 'Burgos'))
plt.legend()
 
plt.tight_layout()
plt.show()

Figura 20. Diagrama de barras a través de listas.

Fuente: elaboración propia.
Diagrama circular
–
En un diagrama circular la variable se representa en forma de círculo y cada valor de la variable tomará una porción del diagrama.
 
politics = ('PSOE', 'PP', 'VOX', 'PODEMOS', 'ERC', 'Cs')
votos = [35, 28, 17, 12, 5, 3 ]
 
explode = (0.2, 0.0, 0, 0, 0, 0)  # Resaltar hacia afuera una porción.
 
plt.pie(votos, explode=explode, labels=politics, autopct='%1.1f%%',
         shadow=True, startangle=90, 
         colors = ('r', 'b', 'g', 'purple', 'yellow', 'orange' ))
 
plt.axis('equal')  # Centrar el gráfico
 
plt.show()

Figura 21. Diagrama circular.

Fuente: elaboración propia.

C O NT I NU A R

3 Una nube de puntos

También llamado diagrama de dispersión o scatter plot, representa el valor de una variable en forma de punto.  Puede ser una sola variable, de
tal forma que se representará el valor de una variable contra el propio índice de la misma.

data_1 = np.random.randint(0, 80, 100)

data_2 = np.random.randint(0, 80, 100)
rangos = np.arange(100)

plt.scatter(rangos, data_1, color='r')

plt.scatter(rangos, data_2, color='b')

plt.xlabel('Estudio 1')
plt.ylabel('Estudio 2')
plt.show()

Figura 22. Nube de puntos.

Fuente: elaboración propia.
Lección 3 de 10

III. Ggplot

Plotnine1 es la implementación del libro The grammar of graphics para Python. Sigue la misma filosofía que Ggplot, es decir: trabajar en capas. Primero se define
con la función “ggplot” el set de datos con el que se trabajará y, posteriormente, se irán añadiendo más capas en las que se incluirán las variables a mostrar, el tipo
de gráfico, color, elementos estéticos como etiquetas, títulos, etc.

 NOTA: se recomienda seguir todo el contenido junto con el siguiente notebook disponible para su descarga:

GGPLOT.ipynb.zip
340.8 KB

GGPLOT.html.zip
387.8 KB

Antes de comenzar a trabajar, descárguese el siguiente dataset (iris.zip). Este dataset contiene información sobre el lirio repartida en las siguientes variables:

Longitud del sépalo en centímetros (sepal_length).

Anchura del sépalo en centímetros (sepal_width).

Longitud del pétalo en centímetros (petal_length).

Anchura del pétalo en centímetros (sepal_length).

Clase de flor: Iris setosa, Iris versicolour e Iris virginica.

El dataset puede ser encontrado en el siguiente enlace.

iris.zip
959 B
Se trata de un dataset con información de diferentes clases (variables numéricas y categóricas), por lo que puede ser utilizado para casi cualquier tipo de
visualización, como se mostrará a lo largo de esta sección.

import pandas as pd

df = pd.read_table('iris.data', sep=',', header = None)

df.columns = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'type']

# Primeras observaciones
df.head()

Figura 23. Iris dataset.

Fuente: elaboración propia.

1Página web de Plotnine. URL disponible en el siguiente enlace. 

C O NT I NU A R

Ejemplo

Se muestran un par de ejemplos básicos; primero, un histograma, que solamente necesita un componente para poder
mostrarse; posteriormente, una nube de puntos que necesita componentes “x” e “y” para poder visualizarse
correctamente. 
Importamos Plotnine. Será necesario instalar la librería, para ello, se acudirá a Anaconda navigator > Environments > Not installed > Plotnine.

Figura 24. Instalación de Plotnine.

Fuente: elaboración propia.

A G R E G A R C O LO R A UN
G G PLO T, HI S T O G R A M A G G PLO T, N UBE DE PUN T O S A G R E G A R C O LO R
HI S T O G R A M A

Predomina la anchura del pétalo con valores de entre 1,5 y 2 centímetros.

from plotnine import *
 
(
     ggplot(df) +
      geom_histogram(aes(x='petal_width'))
)

Figura 25. Ggplot, histograma.

Fuente: elaboración propia.

A G R E G A R C O LO R A UN
G G PLO T, HI S T O G R A M A G G PLO T, N UBE DE PUN T O S A G R E G A R C O LO R
HI S T O G R A M A
Claramente, existen muy pocos tipos de flor con una anchura del pétalo por debajo de 1 centímetro y una anchura del sépalo por debajo de 3
centímetros.
(
     ggplot(df) +
     geom_point(aes(x='petal_width', y = 'sepal_width'))
)
Figura 26. Ggplot, nube de puntos.
Fuente: elaboración propia.

A G R E G A R C O LO R A UN
G G PLO T, HI S T O G R A M A G G PLO T, N UBE DE PUN T O S A G R E G A R C O LO R
HI S T O G R A M A

Vemos que, si no se especifica nada, automáticamente toma los nombres de las variables como etiquetas “x” e “y”. Probaremos a agregar color a las
visualizaciones.
 
(
     ggplot(df) +
     geom_histogram(aes(x='petal_width'), color = 'blue')
)
 
Figura 27. Agregar color a un histograma.
Fuente: elaboración propia.
 A G R E G A R C O LO R A UN
G G PLO T, HI S T O G R A M A G G PLO T, N UBE DE PUN T O S A G R E G A R C O LO R
HI S T O G R A M A

(
     ggplot(df) +
      geom_point(aes(x='petal_width', y = 'sepal_width'), color = 'red')
)
Figura 28. Agregar color a una nube de puntos.
Fuente: elaboración propia.

C O NT I NU A R
 ¡Cuidado con los efectos de color!

El efecto en el histograma no es el deseado, ya que toma por defecto el parámetro color el borde del histograma. En este caso, hay que tener cuidado. Cuando
haya dos componentes diferentes de color, existirán, al menos, color y fill.

(
ggplot(df) +
geom_histogram(aes(x='petal_width'),
color = 'blue',
fill = 'lightgreen',
alpha = 0.2,
linetype='solid')
)

Figura 29. Componentes de color de un histograma.

Fuente: elaboración propia.

Anotación 1
–
Del mismo modo, podemos encontrar aún más elementos estéticos dentro de la capa histograma.

(     
        ggplot(df) +     
         geom_histogram(aes(x='petal_width'),                     
                                           color = 'blue',                     
                                           fill = 'lightgreen',                    
                                           alpha = 0.2,                     
                                           linetype='solid'))
)
Figura 30. Componentes estéticos de un histograma (I).
Fuente: elaboración propia.

Anotación 1.1
–
(
    ggplot(df) +
     geom_histogram(aes(x='petal_width'), 
                    color = 'blue', 
                    fill = 'lightgreen', 
                    alpha = 0.8, 
                    linetype='dashed')
)
Figura 31. Componentes estéticos de un histograma (II).
Fuente: elaboración propia.
Para agregar elementos textuales a una visualización, se utilizará labs, al que podemos agregarle algunos elementos:

title.

“x”.

“y”.

color (solo cuando hay disponible una leyenda).

(
ggplot(df) +
geom_point(aes(x='petal_width', y = 'sepal_width'),
color = 'tomato',
alpha=1,
shape='^',
size = 5,
stroke = 0.2) +
labs(title='Anchura de pétalo y sépalo',
x = 'Anchura Pétalo',
y = 'Anchura Sépalo')
)
 Figura 32. Añadir texto en Ggplot.
Fuente: elaboración propia.

C O NT I NU A R

Una vez vistos los principales elementos descriptivos que podemos agregar a una gráfica, se mostrará cómo agregar gradientes de color o cómo enseñar una
gráfica con base en una etiqueta o variable categórica. En este caso, está la variable type.

df['type'].unique()
 Figura 33. Elementos únicos de la variable type.
Fuente: elaboración propia.

Nos devuelve tres tipos diferentes, por lo que se puede mostrar cualquier observación del dataset con base en el tipo que representa. Cuando se quiera representar
el color con base en una variable categórica, se tendrá que mover el parámetro color dentro de la capa aesthetics (aes).
 1

Figura 34. Color de una gráfica en función de una variable.

Fuente: elaboración propia.

Esta visualización deja muy marcados los tres tipos de flor en función del ancho, tanto del sépalo como del pétalo.

     ggplot(df) +

      geom_point(aes(x='petal_width', y = 'sepal_width', color = 'type'),

                alpha=1,

                shape='.',

                size = 5,

                stroke = 0.2) +

     labs(title='Anchura de pétalo y sépalo', 

          x = 'Anchura Pétalo',

          y = 'Anchura Sépalo',

          color = 'Tipo')

)
 2

Figura 35. Gráfico de barras en Ggplot (I).

Fuente: elaboración propia.

Otro gráfico interesante es el diagrama de barras. Para realizarlo, simplemente se añade como capa “geom_bar”.

(ggplot(df)          

 + aes(x='petal_length')   

 + geom_bar() 

)
 3

Figura 36. Gráfico de barras en Ggplot (II).

Fuente: elaboración propia.

Son predominantes las flores con una longitud del pétalo entre 1 y 2 centímetros.

(ggplot(df)         

 + aes(x='petal_length', fill = 'type')   

 + geom_bar(color = 'black', alpha = 0.6, show_legend=False) 

 + coord_flip() 

C O NT I NU A R

Otra funcionalidad interesante es la de mostrar estadísticas en las visualizaciones. Para ello, existen, principalmente, dos funciones para mostrar líneas verticales
u horizontales en función de un parámetro estadístico:

“geom_vline”: recibe como parámetro “xintercept”.

“geom_hline”: recibe como parámetro “yintercept”.

C O NT I NU A R
 E S TA DÍ S T I C A S E N UN A G R Á F I C A

Esto demuestra que la especie con la longitud de pétalo predominante (Iris setosa) tiene sus valores por debajo de la media en lo que a longitud del
pétalo se refiere.

(ggplot(df)         
 + aes(x='petal_length', fill = 'type')   
 + geom_bar(color = 'black', alpha = 0.6, show_legend=True) 
 + geom_vline(aes(xintercept = df.petal_length.mean()), color = 'red',
              linetype = 'dashed')
  + geom_vline(aes(xintercept = df.petal_length.median()), color = 'blue',
              linetype = 'solid')

)
Figura 37. Estadísticas en una gráfica.
Fuente: elaboración propia.

Facet wrap
–
Uno de los elementos más potentes de Ggplot es la capacidad de generar tantos gráficos de una variable como categorías tenga la variable que se quiera explicar. Esto es lo que
se conoce como facet wraps. Para ello, utilizamos una función con el mismo nombre que recibirá como parámetro el número de categorías “facet_wrap”.

(ggplot(df)         
 + aes(x='petal_length', fill = 'type')   
 + geom_bar(color = 'black', alpha = 0.6, show_legend=True) 
  + geom_vline(aes(xintercept = df.petal_length.mean()), color = 'red',
              linetype = 'dashed')
  + geom_vline(aes(xintercept = df.petal_length.median()), color = 'blue',
              linetype = 'solid')
 + facet_wrap('~type', ncol = 2)
 + labs(
     x = 'Longitud de pétalo',
     y = 'Valores',
     title = 'Diagrama de barras por tipo'
 )
 
 
)
Figura 38. Facet wrap. Mostrar gráficas por categorías.
Fuente: elaboración propia.

Incluir una recta de ajuste

–
Ya se ha visto cómo crear nubes de puntos. Desde Ggplot, también existe la posibilidad de incluir en la misma gráfica una recta de ajuste y su smooth (si existe). Esto lo realizamos
a través de una nueva capa “geom_smooth”.  En esta gráfica, además, se muestra cómo añadir un gradiente de color mediante el comando fill. En este caso, en lugar de una
variable categórica, se utilizará una continua.
(
     ggplot(df) +
      geom_point(aes(x='petal_width', y = 'petal_length', fill = 'petal_width'),
                alpha=0.5,
                shape='o',
                size = 2,
                stroke = 0.2) 
    + geom_smooth(
         aes(x='petal_width', y = 'petal_length')
  )
    + labs(title='Anchura y altura del pétalo', 
          x = 'Anchura Pétalo',
          y = 'Altura Sépalo')
)
Figura 39. Recta de ajuste en una gráfica.
Fuente: elaboración propia.
Generar una gráfica con base en sus categorías
–
Ante estos resultados, existe una gran correlación positiva entre la altura y anchura del pétalo y sépalo.
 
Se ha visto anteriormente cómo generar una gráfica con base en sus categorías con “facet_wrap”; no obstante, también puede hacerse en variables numéricas, aunque no sea tan
explicativo.
(
    ggplot(df) +
      geom_point(aes(x='petal_width', y = 'petal_length', fill = 'petal_width'),
                alpha=0.5,
               shape='o',
                size = 2,
                stroke = 0.2) 
    + geom_smooth(
         aes(x='petal_width', y = 'petal_length')
  )
    + labs(title='Anchura y altura del pétalo', 
          x = 'Anchura Pétalo',
          y = 'Altura Pétalo)
    + facet_wrap('~petal_width', ncol = 4)
)
Figura 40. Facet wrap en una variable numérica.
Fuente: elaboración propia.
Mostrar valores máximos, mínimos cuartiles y la mediana
–
La variable con el ancho del pétalo tiene demasiados valores únicos, por lo que se distorsionan los resultados. En otras palabras, esta visualización no es la más aconsejable para
mostrar la relación entre la altura y anchura del pétalo.
 
Finalmente, se enseña cómo mostrar los valores máximos, mínimos cuartiles y la mediana a través de un diagrama de caja y bigotes, también llamado boxplot.
(
     ggplot(df) 
    + geom_boxplot(
         aes(x='petal_width', y = 'petal_length', fill = 'type'),  
         alpha=0.4, 
         outlier_alpha = 1, 
         outlier_color ='red'
     )
    + labs(title='Anchura y altura del pétalo', 
          x = 'Anchura Pétalo',
          y = 'Altura Sépalo',
          color = 'Ancho Pétalo')
)
Figura 41. Diagrama de caja y bigotes.
Fuente: elaboración propia.
Lección 4 de 10

IV. Seaborn

Seaborn1 actúa como una interfaz de alto nivel sobre Matplotlib para visualización de datos. Se especializa en realizar gráficas de forma más sencilla y con
necesidad de menos código que con Matplotlib.

La especialidad de esta librería se basa en la generación de gráficos estadísticos, aunque las principales funcionalidades que tiene son:

Una API orientada a encontrar las relaciones entre múltiples variables de un dataset.

Gran soporte dedicado a variables categóricas para mostrar sus estadísticas.

Capacidad de comparar diferentes tipos de distribuciones.

Estimación y visualización automática de regresión lineal.

Posibilidad de obtener los múltiples facets de una variable, es decir, la capacidad de mostrar una gráfica para cada valor único de una variable
categórica.

 NOTA: se recomienda seguir todo el contenido junto con el siguiente notebook disponible para su descarga:

SEABORN.ipynb

SEABORN.html

Es recomendable tener importado Pandas para poder realizar operaciones sobre los datasets, además de visualización. También es
conveniente trabajar siempre junto con Pyplot.

SEABORN.ipynb.zip
360.6 KB

SEABORN.html.zip
405.5 KB
Crea un dataset antes de trabajar con Seaborn

Antes de comenzar a trabajar con Seaborn, se crea un dataset que contendrá dos variables numéricas y una categórica generadas de forma aleatoria, simulando un conjunto de
datos provenientes de diferentes cuentas de usuario, a fin de ilustrar los diferentes tipos de gráficas que resultan más aconsejables según el tipo de dato:

# Generamos un dataset artificial

import string
import numpy as np
import pandas as pd
 
letters = ['TRIAL', 'ESTANDAR', 'PREMIUM']
cuenta = [np.random.choice(letters) for i in range(0, 100)]
valores = np.random.randn(100)
acceso = np.random.randint(10, 100, 100)
 
usuarios = pd.DataFrame({
     'TIPO_CUENTA': cuenta,
     'VALOR_CUENTA': valores,
     'ACCESO_CUENTA': acceso
})
 
usuarios.head()

Figura 42. Dataframe para trabajar con Seaborn.

Fuente: elaboración propia.

Se importan las librerías:
 
from matplotlib import pyplot as plt
%matplotlib inline
 
import seaborn as sns

1Página web Seaborn. URL disponible en el siguiente enlace.

C O NT I NU A R

1 Lo primero que se hará es mostrar la simplicidad de Seaborn a través de un gráfico de nube de puntos y su regresión lineal. Esta acción se
realizará con una única función “lmplot”. Los parámetros principales que necesitará la función son “x”, “y” y “data”.

sns.lmplot(x="VALOR_CUENTA", y = 'ACCESO_CUENTA', data = usuarios)

 Figura 43. Nube de puntos y recta de ajuste.
Fuente: elaboración propia.

Puede comprobarse que la relación entre el valor de la cuenta y el número de accesos tiene correlación ligeramente negativa.

C O NT I NU A R

2 Una de las curiosidades de Seaborn es que, al ser de alto nivel, integra varias funciones al mismo tiempo. En la gráfica anterior se ven tres:
nube de puntos, línea de ajuste y el smooth; no obstante, para pintar solamente una nube de puntos, hay que desactivar parámetros. En este
caso, “fit_reg” toma valores “True” o “False”. Lo desactivamos.

sns.lmplot(x="VALOR_CUENTA", y = 'ACCESO_CUENTA',
data = usuarios, fit_reg=False)
 Figura 44. Nube de puntos sin recta de ajuste.
Fuente: elaboración propia.

C O NT I NU A R

3 De un modo similar a Ggplot, se puede mostrar el color de la gráfica en función de otra variable. En este caso, se mostrará el color por los tres
niveles de la variable “TIPO_CUENTA”. Para mostrar el color, utilizamos el parámetro “hue”.

sns.lmplot(x="VALOR_CUENTA", y = 'ACCESO_CUENTA',
data = usuarios, hue = 'TIPO_CUENTA',
fit_reg=False)
 Figura 45. Color en función de una variable en Seaborn.
Fuente: elaboración propia.

C O NT I NU A R

4 En esta ocasión los grupos no son tan diferenciados como en la sección de Ggplot a través del dataset iris. A simple vista, no existe una
variable que separe los datos en grupos más homogéneos.

 Algunos tipos de gráfico no toman parámetros obligatorios “x” e “y”, por lo que podemos pasar todo el
dataset completo.

sns.boxplot(data=usuarios)
sns.violinplot(data=usuarios)
 Figura 46. Diagramas de caja, bigote y violín.
Fuente: elaboración propia.

Si se observan las gráficas anteriores, se ve que, pese a que Seaborn permite realizar una visualización de todo el dataset, no son la representación más correcta
por las siguientes razones:

Las escalas de la primera gráfica donde se muestra un boxplot son demasiado dispares, esto provoca que la variable VALOR_CUENTA apenas
tenga representación. Sería una mejor representación un diagrama de barras para mostrar el número de elementos de cada variable.

Pasa algo similar con el diagrama de violín: las variables tienen una escala muy diferente y no puede apreciarse con claridad la densidad para
cada variable. En esta ocasión, sería mucho más aconsejable mostrar un diagrama de densidad por separado para las dos variables numéricas
de cuenta.

C O NT I NU A R

No obstante, se pueden siempre definir los conjuntos de datos que queremos mostrar en la gráfica.

DE F I N I R E L C O N JUN T O DE DAT O S DE F I N I R LO S C O LO R E S PR O PI O S
 DE F I N I R E L C O N JUN T O DE DAT O S DE F I N I R LO S C O LO R E S PR O PI O S

No obstante, se pueden siempre definir los conjuntos de datos que queremos mostrar en la gráfica.

sns.violinplot(x=usuarios.TIPO_CUENTA, 
                y=usuarios.VALOR_CUENTA, 
                data=usuarios)

Observamos que, de forma separada, sí es una buena idea realizar diagrama de violín, puesto que puede verse claramente cómo son las distribuciones
del valor de la cuenta en función de su tipo.
Figura 47. Diagramas violín por variable categórica.
Fuente: elaboración propia.

DE F I N I R E L C O N JUN T O DE DAT O S DE F I N I R LO S C O LO R E S PR O PI O S

También se puede definir un tipo de colores propio. Simplemente tenemos que pasar una lista con los valores al parámetro palette.

sns.boxplot(x=usuarios.TIPO_CUENTA, 
             y=usuarios.VALOR_CUENTA, 
             data=usuarios,
             palette=['red', 'blue', 'green'])

Figura 48. Parámetro palette.

Fuente: elaboración propia.
 C O NT I NU A R

Lo mismo ocurre con el diagrama de caja y bigotes: es mucho más recomendable realizar la visualización del tipo de cuenta por separado, explicando sus valores
en función del tipo de cuenta. En vista de los resultados, existen menos cuentas de tipo estándar que del tipo trial y premium; además, la cuenta tipo estándar es la
que tiene la mediana (cercana a 1) más diferente que los otros dos tipos de cuenta (cercanos a cero).

 Una característica muy importante de Seaborn es que nos permite solapar gráficas entre sí.
 1

Figura 49. Juntar dos gráficas en la misma visualización.

Fuente: elaboración propia.

Utilizaremos nuestro anterior boxplot y añadiremos otro tipo de gráfica que muestra la dispersión de los puntos, de manera que
refleja la estructura de un boxplot. Utilizaremos swarmplot.

sns.boxplot(x=usuarios.TIPO_CUENTA, 

             y=usuarios.VALOR_CUENTA, 

             data=usuarios,

            palette=['red', 'blue', 'green'],

             saturation=0.3)

sns.swarmplot(x=usuarios.TIPO_CUENTA, 

               y=usuarios.VALOR_CUENTA, 

               data=usuarios, 

               color='k')
 2

Figura 50. Añadir texto en Seaborn.

Fuente: elaboración propia.

En esta representación, simplemente se ha añadido cada observación en forma de punto en función de su valor y del tipo de cuenta.

Se pueden añadir títulos y texto para los ejes “x” e “y” del mismo modo que con Pyplot:

sns.boxplot(x=usuarios.TIPO_CUENTA, 

             y=usuarios.VALOR_CUENTA, 

            data=usuarios,

             palette=['red', 'blue', 'green'],

             saturation=0.3)

sns.swarmplot(x=usuarios.TIPO_CUENTA, 

               y=usuarios.VALOR_CUENTA, 

               data=usuarios, 

              color='k')

plt.title('Valor de la cuenta por tipo')

plt.xlabel('TIPO DE CUENTA')

plt.ylabel('VALOR DE LA CUENTA')

C O NT I NU A R
 Ejemplo

Tal y como se ha mencionado anteriormente, al ser una librería de alto nivel, integra diferentes operaciones sobre una misma gráfica. En el
siguiente ejemplo con distplot, se ve cómo realizar sin esfuerzo un histograma y diagrama de densidad al mismo tiempo.

sns.distplot(a=usuarios.VALOR_CUENTA, color='blue')

Figura 51. Histograma y función de densidad.

Fuente: elaboración propia.

C O NT I NU A R

Otra característica de Seaborn es la de ordenar automáticamente los datos cuando se realiza un diagrama de barras con countplot, tal y como se ha señalado en las
visualizaciones anteriores, el tipo de cuenta estándar será el que menor representación tenga:
sns.countplot(x=usuarios['TIPO_CUENTA'], data=usuarios)
Figura 52. Diagrama de barras.

Fuente: elaboración propia.

C O NT I NU A R

1 Faceting

Al igual que con Ggplot, también se puede realizar faceting y mostrar subgráficas por cada valor de una variable, ya sea categórica o numérica.
La función encargada para realizar esta acción es factorplot.

sns.factorplot(x='VALOR_CUENTA',
y='ACCESO_CUENTA',
hue='TIPO_CUENTA',
data=usuarios,
col='TIPO_CUENTA',
kind='swarm')
 Figura 53. Faceting por variable categórica en Seaborn.
Fuente: elaboración propia.

C O NT I NU A R

2 Heatmap

Anteriormente se ha realizado una gráfica que mostraba una nube de puntos sobre todas las observaciones con su tipo de cuenta. Sin
embargo, en esta ocasión, realizando una nube de puntos para cada tipo de cuenta, se obtiene que no existe ningún elemento que diferencie
dos datos.

Otra característica importante también mencionada al principio del contenido es que Seaborn está integrado con varias funciones de Pandas.
En este caso, se realizará una visualización con base en una matriz de correlación con heatmap.

Como hay muy pocas variables numéricas en nuestro dataset, generaremos algunas más.

new_df = usuarios.copy()

new_df['SQUARE'] = new_df.VALOR_CUENTA**2
new_df['CUBIC'] = new_df.VALOR_CUENTA**3
new_df['NEW_INTS_1'] = np.random.randint(10, 100, 100)
new_df['NEW_INTS_2'] = np.random.randint(10, 100, 100)

sns.heatmap(new_df.corr(), cmap='Greys')
 Figura 54. Mapa de calor.
Fuente: elaboración propia.

 Nota: se recomienda ver el siguiente enlace para conocer los diferentes mapas de colores.

C O NT I NU A R

3 Diagrama pairs

De forma muy simple, es posible ver que la variable con la transformada cúbica sobre el valor de la cuenta tienen una gran relación lineal entre
sí.

Seaborn también dispone de una opción para realizar diagramas pairs o matrices de visualización. La función encargada de ello es pairplot:

sns.pairplot(data=new_df, hue='TIPO_CUENTA')
 Figura 55. Diagrama entre pares.
Fuente: elaboración propia.

C O NT I NU A R

4 Jointplot

Finalmente, se muestra cómo realizar gráficos conjuntos, es decir: por una parte, mostrar una nube de puntos entre dos variables y, al mismo
tiempo enseñar sus distribuciones. Para este tipo de visualización, disponemos de joinplot:

sns.jointplot(x='ACCESO_CUENTA', y='VALOR_CUENTA', data=new_df, kind='reg')

Figura 56. Diagrama conjunto.
Fuente: elaboración propia.
Lección 5 de 10

V. Bokeh

En Python, una de las librerías más potentes para comunicar e interactuar con los resultados, Bokeh1, destaca por las siguientes características:

Hace simple la creación de gráficos dinámicos.

Permite crear widgets en los que mostrar la evolución de un gráfico con diferentes valores.

Sus gráficos y cuadros de mando pueden ser publicados en páginas web o notebooks.

Optimizada para trabajar con las librerías más importantes de Python: Pandas, Numpy, Scipy, OpenCV, Scikit-Learn, etc.

 NOTA: se recomienda seguir todo el contenido junto con el siguiente notebook, disponible para su descarga:

BOKEH.ipynb.zip
29.5 KB

BOKEH.html.zip
74.2 KB
 1

El primer paso será importar la librería Bokeh con la funcionalidad de mostrar los resultados de las gráficas
dentro de notebook.

from bokeh.io import output_notebook, show

 2

Figura 57. Interfaz de Bokeh.

Fuente: elaboración propia.

Ahora, es importante cerciorarse de que Bokeh puede trabajar correctamente; para ello, cargaremos la función “output_notebook”.

output_notebook()
 3

No arroja ningún mensaje de error, así que comienza la creación de nuestro primer gráfico dinámico. 

1Página web de Bokeh. URL disponible en el siguiente enlace. 

C O NT I NU A R

El primer elemento que habrá que configurar es el espacio que ocupará nuestro gráfico, en otras palabras: inicializaremos el espacio gráfico. Para ello, se utilizará la función
figure con los siguientes parámetros: plot_width, plot_height.

from bokeh.plotting import figure

 
p = figure(plot_width=400, plot_height=400)

Lo siguiente será añadir el tipo de gráfico en sí. Bokeh soporta una gran cantidad de gráficos. Comenzaremos por un gráfico lineal, pero se recomienda visualizar todos los tipos
de gráficos principales que se pueden realizar desde la función figure. Accede en el siguiente enlace. 
 
Asimismo, si se quieren ver algunas demos de ejemplo sobre dashboards que pueden realizarse en Bokeh, están disponibles en el siguiente link. 
Un gráfico de líneas lo realizaremos a través de la función line:
 
p.line([1, 2, 3, 4, 5, 6, 7, 8] ,[20, 3, 12, 28, 15, 6, 19, 11])

Finalmente, para mostrar el gráfico se hará uso de la función importada de “bokeh.io” show:
 
show(p)

Figura 58. Gráfico de líneas con Bokeh.

Fuente: elaboración propia.

Aparece el gráfico y, a diferencia de otros paquetes de visualización, podemos desplazarnos en el gráfico, hacer zoom, mover con la rueda del ratón y guardar el gráfico de forma
muy simple a través del menú “Opciones”.

C O NT I NU A R
1 Agregamos nuevos parámetros: 

p = figure(plot_width=400, plot_height=400)

p.line([1, 2, 3, 4, 5, 6, 7, 8] ,[20, 3, 12, 28, 15, 6, 19, 11],

color = 'red', line_width=5, line_alpha = 0.5)
show(p)

Figura 59. Nuevos elementos en gráfico de líneas.

Fuente: elaboración propia.

C O NT I NU A R

2 Se muestra otro estilo de gráfico: un scatter plot. Se utiliza la función circle:

p = figure(plot_width=500, plot_height=500)

p.circle([1, 2, 3, 4, 5, 6, 7, 8] ,[20, 3, 12, 28, 15, 6, 19, 11],

color = 'red', line_width=5, line_alpha = 0.5)
show(p)
 Figura 60. Nube de puntos (I).
Fuente: elaboración propia.

C O NT I NU A R

3 Se añaden más opciones y, en esta ocasión en lugar de utilizar listas, se comprobará su integración con arrays.

p = figure(plot_width=500, plot_height=500)

import numpy as np

normal = np.random.rand(100)
square = normal**2

p.circle(normal ,square,
fill_color = 'lightgreen',
line_alpha = 0.8,
line_color = 'red',
radius = 0.01)
show(p)
 Figura 61. Nube de puntos (II).
Fuente: elaboración propia.

C O NT I NU A R

4 En esta visualización se aprecia el valor que toman entre sí el primer y segundo array.

También es posible combinar dos estilos de gráfico juntos. Probaremos a realizar un scatter plot de dos maneras: a través de círculos circle y
cuadrados square.

p = figure(plot_width=500, plot_height=500)

import numpy as np

normal = np.random.rand(100)
square = normal**2
cubic = normal**3
polynomic = normal**4
p.circle(normal ,square,
fill_color = 'lightgreen',
line_alpha = 0.8,
line_color = 'red',
radius = 0.01)

p.square(cubic ,polynomic,
fill_color = 'lightblue',
line_alpha = 1,
line_color = 'brown',
size = 8)
show(p)

Figura 62. Nube de puntos (III).

Fuente: elaboración propia.

C O NT I NU A R
5 Para añadir texto a nuestra visualización, hay que acceder a los propios atributos del objeto figure. Para añadir texto en los ejes “x” e “y”, hay
que acceder a los siguientes atributos:

“xaxis”.

“yaxis”.

Para ambos atributos, se dispone del atributo “axis_label”.

Se puede añadir el título de un gráfico a través del parámetro title dentro de la función figure cuando inicializamos el gráfico.

p = figure(plot_width=500, plot_height=500, title='Transformaciones de distribución normal')

normal = np.random.rand(100)
square = normal**2
cubic = normal**3
polynomic = normal**4

p.circle(normal ,square,
fill_color = 'lightgreen',
line_alpha = 0.8,
line_color = 'red',
radius = 0.01)

p.square(cubic ,polynomic,
fill_color = 'lightblue',
line_alpha = 1,
line_color = 'brown',
size = 8)

p.xaxis.axis_label = 'Valor de distribución X'

p.yaxis.axis_label = 'Valor de distribución Y'

show(p)
 Figura 63. Añadir texto a una gráfica en Bokeh.
Fuente: elaboración propia.

C O NT I NU A R

6 También se puede cambiar elementos descriptivos de los ejes:

p = figure(plot_width=500, plot_height=500, title='Transformaciones de distribución normal')

normal = np.random.rand(100)
square = normal**2
cubic = normal**3
polynomic = normal**4

p.circle(normal ,square,
fill_color = 'lightgreen',
line_alpha = 0.8,
line_color = 'red',
radius = 0.01)

p.square(cubic ,polynomic,
fill_color = 'lightblue',
line_alpha = 1,
line_color = 'brown',
size = 8)

p.xaxis.axis_label = 'Valor de distribución X'

p.yaxis.axis_label = 'Valor de distribución Y'

p.yaxis.major_label_text_color = "red"
p.yaxis.major_label_orientation = "vertical"
p.xaxis.axis_line_width = 2
p.xaxis.axis_line_color = "blue"
p.xaxis.major_label_text_color = "blue"

show(p)

Figura 64. Modificar elementos en los ejes. 

Fuente: elaboración propia.

C O NT I NU A R
A continuación, se muestra cómo generar un diagrama de barras.
 1

Primero, se diseñará un dataframe sencillo que contendrá para un tipo de fruta un volumen de venta asociado y los ingresos
obtenidos:

import pandas as pd

items = ['Naranjas', 'Fresas', 'Manzanas', 'Plátanos', 'Mango']

volumen_venta = np.random.randint(100, 1000, 5)

ingresos_totales = np.random.randint(1000, 25000, 5)

df = pd.DataFrame({

    'Productos': items,

    'Volumen': volumen_venta,

    'Ingresos': ingresos_totales

})
 2

Figura 65. Diagrama de barras. 

Fuente: elaboración propia.

Seguidamente, con “vbar” se mostrará un diagrama de barras sobre el volumen de ventas por producto.

p = figure(x_range=df['Productos'], plot_height=350, 

           title="Volumen de ventas")

p.vbar(x=df['Productos'], top=df['Volumen'], 

       width=0.9, 

       fill_color=['#DF5837', '#A9E915', '#CA09A9', '#1E82A8', '#F9E13A'], 

       fill_alpha=0.6)

# Podemos generar colores en hexadecimal con https://htmlcolorcodes.com/

show(p)

La gráfica anterior revela que el mango es la futa que mayor volumen de ventas genera.

C O NT I NU A R
Aunque de una forma algo más compleja que utilizando Seaborn o Ggplot, en Bokeh también se pueden generar gradientes de color en función de una variable.
Para ello, hay que tener en cuenta tres funciones:

“LinearColorMapper”: se pasa como parámetro palette, que toma valor de una paleta de colores que se puede encontrar disponible en el siguiente enlace  low:
valor mínimo de la variable; high: valor máximo de la variable. Se genera una secuencia de colores en función del rango de nuestra variable.

“ColorBar”: dentro de los parámetros que recibe, el más importante es “color_mapper”, que recibe un objeto “LinearColorMapper” generado previamente. Esta
función genera una leyenda con los colores de nuestra variable.

Dentro de la función del gráfico, en este caso nube de puntos, en el parámetro color se utilizará la función transform, a la cual se pasará el nombre de la
columna y el objeto “LinearColorMapper”.

from bokeh.models import LinearColorMapper, ColorBar

from bokeh.transform import transform

color_mapper = LinearColorMapper(palette="Viridis256", low=df.Ingresos.min(), high=df.Ingresos.max())

color_bar = ColorBar(color_mapper=color_mapper, label_standoff=12, location=(0,0), title='Ingresos')

p = figure(x_axis_label='Volumen de ventas', # Otra forma de añadir texto en los ejes

y_axis_label='Ingresos totales',
plot_height=400)

p.circle(x='Volumen', y='Ingresos',
color=transform('Ingresos', color_mapper),
size=20, alpha=0.6,
source=df)

p.add_layout(color_bar, 'right') # Posición del gradiente de color

show(p)
 Figura 66. Gradiente de color. 
Fuente: elaboración propia.

Obtenemos el volumen de ventas asociado a los ingresos. Curiosamente, el mayor volumen de ventas es el que menos ingresos produce.

C O NT I NU A R

Se puede desactivar el panel lateral para gestionar el gráfico y añadir los siguientes parámetros a la función figure.

tools: se deja vacío.

“toolbar_location”: valor none.

Finalmente, se muestra cómo añadir elementos dinámicos a un gráfico, es decir: que cuando se pase el cursor por un elemento del gráfico, nos muestre
información. Esto en Bokeh se consigue a través de “HoverTool”. Se trata de una función que integra funcionalidades para mostrar diferentes elementos textuales
en los datos. Es importante mencionar que, para poder utilizar las funciones de “HoverTool”, también hay que pasar nuestros datos a un tipo especial de Bokeh,
llamado sources. Para ello, se utiliza “ColumnDataSource”. El funcionamiento, por lo tanto, es el siguiente:
 Se toma el set de datos y se pasa a la función “ColumnDataSource”. Sources nos devolverá los tipos de columnas que podemos mostrar en
nuestro gráfico; por ejemplo, si se pasa a la función un conjunto de datos previamente agrupado con “groupby”, permitirá acceder a
estadísticas básicas como mínimo, máximo, media y cuartieles. Esta información se podrá proyectar posteriormente en el gráfico.

Cuando se defina el tipo de gráfico, no se utilizarán como tal los nombres de las columnas del dataframe, sino las de sources.

Cuando se haya definido el tipo de gráfica, se llamará a la función “HoverTool” y a su atributo “tooltips”, en el cual se pasará la información a
proyectar con la siguiente estructura: 

'Nombre que se mostrará': @columna_de_source.

C O NT I NU A R

from bokeh.models import ColumnDataSource, HoverTool

from bokeh.transform import factor_cmap
from bokeh.palettes import Spectral5

source = ColumnDataSource(df)
source.column_names

groups = df.groupby(by=['Productos'])
source_dos = ColumnDataSource(groups)
source_dos.column_names

Figura 67. Columnas de un objeto “ColumnDataSource”. 

Fuente: elaboración propia.
 C O NT I NU A R

products = source.data['Productos'].tolist()

p = figure(x_range = products,
plot_height=350,
title="Volumen de ventas")

color_map = factor_cmap(field_name='Productos',
palette=Spectral5, factors=products)

p.vbar(x='Productos', top='Volumen', source = source,

width = 0.5, color=color_map)

# Podemos generar colores en hexadecimal con https://htmlcolorcodes.com/

hover = HoverTool()
hover.tooltips=[
('Volumen de ventas', '@Volumen'),
('Ingresos totales', '@Ingresos')
]

p.add_tools(hover)

# Podemos generar colores en hexadecimal con https://htmlcolorcodes.com/

show(p)
Figura 68. Elementos dinámicos de un gráfico. 
Fuente: elaboración propia.
Lección 6 de 10

VII. Resumen

Repasa los conocimientos adquiridos en la unidad

En esta unidad, se ha continuado la progresión en el conocimiento de las herramientas necesarias para el procesamiento de datos. Esta vez se ha mostrado su aplicación en
visualización de datos, una vez se conoce como utilizar las diferentes estructuras de datos (diccionario de datos, tuplas y listas), así como los elementos de las principales
librerías de ciencia de datos, dataframes y arrays.

Para adquirir competencias en visualización de datos, se ha aprendido a trabajar con las principales librerías de visualización en Python, que son Matplotlib, Ggplot, Seaborn y
Bokeh. Por lo tanto, se han añadido diferentes elementos a una gráfica, como capas o estadísticas, y, por último, elementos interactivos para ayudar a la hora de mostrar
resultados.
Lección 7 de 10

VI. Caso práctico con solución

Aplica los conocimientos adquiridos en esta unidad

ENUNCIADO

Con el CSV de acciones de Apple (“AAPL.csv”), realiza las siguientes visualizaciones:

Matplotlib: obtén un diagrama de barras de las cinco primeras fechas del dataset para los precios de apertura y cierre.

Ggplot: realiza una nube de puntos con el volumen de acción y el cierre ajustado. Muestra, además, la línea de ajuste (regresión lineal), entre ambas variables. Utiliza un
gradiente de color mediante el precio de cierre ajustado.

Seaborn 1: realiza un mapa de calor mediante la correlación del dataframe.

Seaborn 2: obtén un histograma y desactiva la función de densidad.

Bokeh: realiza una gráfica de toda la serie temporal sobre los precios más altos y bajos. Para que se diferencien más las líneas, resta 40 puntos a todos los precios más
bajos.

AAPL.csv
162.8 KB
 VER SOLUCIÓN

EJERCICIO_1_SOLUCION.ipynb
635.8 KB
Lección 8 de 10

VII. Enlaces de interés

Tutorial de Matplotlib.

ABRIR ENLACE

Tutorial de Ggplot (Plotnine)

ABRIR ENLACE

Tutorial de Seaborn

ABRIR ENLACE

Tutorial de Bokeh

ABRIR ENLACE
Lección 9 de 10

VIII. Glosario

El glosario contiene términos destacados para la comprensión de la unidad

Matplotlib
–
Paquete de Python dedicado a la creación de gráficos estadísticos o animados en Python.

Ggplot
–
Paquete de Python dedicado a la visualización de datos por capas.

Seaborn
–
Paquete de Python implementado sobre Matplotlib que incluye funciones de visualización de datos de alto nivel, especialmente para la estadística.

Bokeh
–
Paquete de Python especializado en realización de gráficos dinámicos.
Visualización de datos
–
Parte de la ciencia de datos que consiste en enfatizar detalles sobre los datos o comunicar un conjunto de datos a través de gráficas. 

Gradiente de color
–
Representación de los datos a través de un color que cambia en función del valor de una variable.

Gráfico de línea
–
Visualización de datos que consiste en representar un conjunto de datos a través de líneas que unen los datos entre sí.

Nube de puntos
–
Consiste en una visualización de datos en donde cada dato es representado a través de un punto.

Gráfico de serie temporal

–
Visualización de datos que debe tener en el eje de abscisas datos relativos a fechas (temporales). Cada valor del eje de ordenadas es unido mediante puntos o líneas en función de
su fecha.

Diagrama de barras
–
Visualización de datos que consiste en representar de forma horizontal o vertical el valor de cada dato a través de una barra.

Diagrama circular
–
Visualización de datos en la que se disponen de forma circular. Cada dato representa una parte de ese círculo.

Histograma
–
Visualización de datos en la que una variable se representa a través de barras, donde la superficie de cada barra es proporcional a la frecuencia de los valores representados.
Lección 10 de 10

IX. Bibliografía

Yim, A. Matplotlib for Python developers effective techniques for data visualization with Python, 2nd Edition. Packt Publishing ; 2018.

Jolly, K. Hands on data visualization with Bokeh Interactive web plotting for Python using Bokeh. Packt
Publishing; 2018.