En nuestro primer tutorial de visualización de datos con Bokeh aprendiste a crear visualizaciones desde cero usando glifos. Ahora puedes ampliar ese concepto y generar gráficos a partir de distintas estructuras de datos, como arrays y dataframes. En este tutorial aprenderás a representar datos con arrays de NumPy, dataframes en Pandas y ColumnDataSource usando Bokeh. ColumnDataSource es el núcleo de Bokeh y permite compartir datos entre varios gráficos y widgets.
Gráficos de Bokeh a partir de arrays de NumPy
Crear gráficos de líneas con arrays de NumPy
# Importar paquetes
import numpy as np
import random
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Crear un array
x_array = np.array([10,20,30,40,50,60])
y_array = np.array([50,60,70,80,90,100])
# Crear un gráfico de líneas
plot = figure()
plot.line(x_array, y_array)
# Mostrar el gráfico
show(plot)
Crear gráficos de dispersión con arrays de NumPy
# Importar paquetes
import numpy as np
import random
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Crear arrays
x_arr = np.array([10,11,12,13,14,15,16])
y_arr = np.array([17,18,19,20,21,22,23])
# Crear el gráfico
plot = figure(title = "Scatter plot", x_axis_label = "Label name of x axis", y_axis_label ="Label name of y axis")
plot.circle(x_arr,y_arr, size = 30, alpha = 0.5)
# Mostrar el gráfico
show(plot)
Esto genera el siguiente gráfico:
Crear gráficos con dataframes de Pandas
Trazar líneas con dataframes de Pandas
Los datos de este ejemplo se obtienen de Kaggle. El conjunto de datos contiene todas las acciones del índice S&P 500 durante cinco años hasta diciembre de 2018. El archivo incluye siete columnas:
- Date: fecha en formato aa-mm-dd
- Open: precio de apertura
- High: precio máximo del día
- Low: precio mínimo del día
- Close: precio de cierre del día
- Volume: volumen negociado en el día
- Name: ticker de la acción
Queremos ver la tendencia de la acción de Google en el periodo de cinco años. Primero cargamos los datos con Pandas y después consultamos las cinco primeras filas del dataframe.
# Importar paquetes
import pandas as pd
# Cargar datos
df = pd.read_csv('all_stocks_5yr.csv')
df.head()
# Centrarse en la acción de Google
df_goog = df[df['Name'] == 'GOOG']
# Convertir la columna de fecha a serie temporal
df_goog['date'] = pd.to_datetime(df_goog['date'])
plot = figure(title= "Pandas Line Plot", x_axis_type = 'datetime', x_axis_label = 'date', y_axis_label= 'Prices')
plot.line(x = df_goog['date'], y = df_goog['high'])
# Mostrar el gráfico
show(plot)
En el gráfico fue necesario convertir la columna de fecha a datetime para representar fechas en el eje x. Además, la función line (glifo en Bokeh) se usa para generar una serie temporal de los precios máximos de Google.
Crear un gráfico de dispersión desde un dataframe de Pandas
En esta sección usamos los datos abiertos del S&P 500 disponibles en Kaggle. En este ejemplo queremos ver la correlación entre los precios de las acciones de Google y Apple. Puedes aprender más sobre la correlación aquí.
# Importar paquetes necesarios
# Importar paquetes
import pandas as pd
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Cargar datos
df = pd.read_csv('all_stocks_5yr.csv')
# Seleccionar acciones de Google y Apple
df_goog = df[df['Name'] == 'GOOG']
df_apple = df[df['Name'] == 'AAPL']
# Seleccionar solo las columnas 'date' y 'high' para Google y Apple
df_goog = df_goog[['date','high']]
df_apple = df_apple[['date','high']]
# Renombrar la columna 'high' a 'high_goog' y 'high_apple'
df_goog.rename(columns={'high': 'high_goog'}, inplace=True)
df_apple.rename(columns={'high': 'high_apple'}, inplace=True)
df_merged = pd.merge(df_goog, df_apple, how='inner', on='date')
# Ver las cinco primeras filas
df_merged.head(5)
La fusión garantiza que los precios diarios correspondan por fecha. Así evitamos correlacionar precios de días distintos, lo que llevaría a conclusiones estadísticas erróneas.
# Crear el gráfico de dispersión
plot = figure(title= "Pandas Scatter Plot", x_axis_label = "Apple high prices", y_axis_label= "Google high prices")
plot.circle(x = df_merged['high_apple'], y = df_merged['high_goog'],color = 'red', size = 10, alpha = 0.8)
# Mostrar el gráfico
show(plot)
Los círculos representan la relación entre los precios máximos de Apple y Google. Hay una correlación positiva general entre los precios de ambas acciones.
Crear gráficos de Bokeh con ColumnDataSource
El objetivo de ColumnDataSource es permitirte crear distintos gráficos usando los mismos datos. En resumen, te permite construir una base de datos para reutilizar en varios gráficos y análisis. Esto te ahorrará tiempo, ya que no tendrás que cargar los datos varias veces en Jupyter Notebook.
ColumnDataSource es similar a un diccionario de Python, donde el valor de los datos de una columna tiene como clave una cadena con el nombre de esa columna.
Crear gráficos de líneas con ColumnDataSource
# Importar paquetes
from bokeh.io import output_file, show
from bokeh.plotting import figure, ColumnDataSource
# Crear el objeto ColumnDataSource
df_goog['date'] = pd.to_datetime(df_goog['date'])
data = ColumnDataSource(df_goog)
# Crear el gráfico de serie temporal
plot = figure(x_axis_type='datetime',
title='GOOG high prices ts plot',
x_axis_label = "Date",
y_axis_label = "Prices in $")
plot.line(x='date', y = 'high_goog', source = data, color = 'green')
show(plot)
El gráfico muestra cómo evolucionaron los precios máximos de Google a lo largo de 5 años, con la línea indicando cada punto de precio de la acción.
Para crear este gráfico, pasamos el dataframe completo de la acción de Google a la función ColumnDataSource y lo guardamos en una variable llamada data.
Luego usamos el argumento source para pasar estos datos a la función del gráfico. Así podemos usar directamente los nombres de las columnas al crear el gráfico, en lugar de llamar al dataframe una y otra vez.
Por último, usamos la función line para generar la línea verde que representa los puntos de datos.
Crear gráficos de dispersión con ColumnDataSource
En este código pasamos el dataframe completo de la acción de Google a ColumnDataSource (igual que en el ejemplo del gráfico de líneas). El dataframe se guarda en ColumnDataSource como una variable llamada data. Primero creamos el gráfico de líneas llamando directamente a los nombres de columna. Por último, usamos la función diamond para generar los diamantes rojos que representan cada punto de datos.
# Importar paquetes
from bokeh.io import output_file, show
from bokeh.plotting import figure, ColumnDataSource
# Crear el objeto ColumnDataSource
df_goog['date'] = pd.to_datetime(df_goog['date'])
data = ColumnDataSource(df_goog)
# Crear el gráfico de serie temporal
plot = figure(x_axis_type='datetime',
title='GOOG high prices ts plot',
x_axis_label = "Date",
y_axis_label = "Prices in $")
plot.line(x='date', y = 'high_goog', source = data, color = 'green')
plot.diamond(x='date', y = 'high_goog', source = data, color = 'red')
show(plot)
El gráfico muestra la evolución de la acción de Google en un periodo de 5 años, con los diamantes rojos indicando cada punto de precio.
Conclusión
Este tutorial te ha presentado las estructuras de datos más comunes con las que probablemente te encontrarás en Python y cómo usarlas para dar vida a tus datos. Aunque Bokeh no es la única opción para visualizar en Python, se diferencia de Matplotlib o Seaborn por su facilidad de uso y sus capacidades interactivas. En el próximo tutorial, pondrás en práctica el uso de layouts para crear visualizaciones eficaces e interactivas. Si quieres profundizar en todo lo que ofrece Bokeh para la visualización de datos, echa un vistazo al curso de DataCamp Interactive Data Visualization with Bokeh.
