Dans notre premier tutoriel Data Visualization with Bokeh, vous avez appris à construire des visualisations à partir de zéro avec des glyphes. Vous pouvez désormais étendre ce concept et créer des graphiques à partir de différentes structures de données comme des tableaux et des dataframes. Dans ce tutoriel, vous apprendrez à tracer des données avec des tableaux NumPy, des dataframes Pandas et ColumnDataSource dans Bokeh. ColumnDataSource est au cœur de Bokeh : il permet de partager les mêmes données entre plusieurs graphiques et widgets.
Graphiques Bokeh à partir de tableaux NumPy
Créer des graphiques linéaires avec des tableaux NumPy
# Import des packages
import numpy as np
import random
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Créer un tableau
x_array = np.array([10,20,30,40,50,60])
y_array = np.array([50,60,70,80,90,100])
# Créer un graphique de ligne
plot = figure()
plot.line(x_array, y_array)
# Afficher le graphique
show(plot)
Créer des nuages de points avec des tableaux NumPy
# Import des packages
import numpy as np
import random
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Créer des tableaux
x_arr = np.array([10,11,12,13,14,15,16])
y_arr = np.array([17,18,19,20,21,22,23])
# Créer le graphique
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)
# Afficher le graphique
show(plot)
Vous obtenez le graphique suivant :
Créer des graphiques avec des dataframes Pandas
Tracer des courbes avec des dataframes Pandas
Les données de cet exemple proviennent de Kaggle. Le jeu de données contient toutes les actions de l’indice S&P 500 sur cinq ans, jusqu’en décembre 2018. Le fichier comporte sept colonnes :
- Date - date du jour au format aa-mm-jj
- Open - prix d’ouverture de l’action
- High - plus haut cours de la journée
- Low - plus bas cours de la journée
- Close - prix de clôture du jour
- Volume - volume d’actions échangées dans la journée
- Name - ticker de l’action
Nous souhaitons visualiser la tendance du cours de l’action Google sur cette période de cinq ans. Commençons par charger les données avec Pandas, puis affichons les cinq premières lignes du dataframe.
# Import des packages
import pandas as pd
# Charger les données
df = pd.read_csv('all_stocks_5yr.csv')
df.head()
# Se concentrer sur l'action de Google
df_goog = df[df['Name'] == 'GOOG']
# Convertir la colonne date en série temporelle
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'])
# Afficher le graphique
show(plot)
Pour ce graphique, il a fallu convertir la colonne de date en type datetime afin d’afficher correctement les dates sur l’axe des abscisses. De plus, la fonction line (un glyphe dans Bokeh) est utilisée pour générer une série temporelle des plus hauts de Google.
Créer un nuage de points à partir d’un dataframe Pandas
Dans cette section, nous utilisons les données open source du S&P 500 disponibles sur Kaggle. Ici, nous voulons observer la corrélation entre les cours de Google et ceux d’Apple. Pour en savoir plus sur la corrélation, consultez cet article.
# Import des packages nécessaires
# Import des packages
import pandas as pd
from bokeh.io import output_file, show
from bokeh.plotting import figure
# Charger les données
df = pd.read_csv('all_stocks_5yr.csv')
# Sélectionner les actions Google et Apple
df_goog = df[df['Name'] == 'GOOG']
df_apple = df[df['Name'] == 'AAPL']
# Ne garder que les colonnes 'date' et 'high' pour Google et Apple
df_goog = df_goog[['date','high']]
df_apple = df_apple[['date','high']]
# Renommer la colonne 'high' en 'high_goog' et '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')
# Afficher les cinq premières lignes
df_merged.head(5)
La jointure garantit que les cours quotidiens se correspondent bien par date. Cela évite de corréler des prix provenant de dates différentes, ce qui conduirait à des inférences statistiques erronées.
# Créer le nuage de points
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)
# Afficher le graphique
show(plot)
Chaque cercle représente la relation entre les plus hauts d’Apple et ceux de Google. On observe une corrélation globalement positive entre les cours des deux actions.
Créer des graphiques Bokeh avec ColumnDataSource
L’objectif de ColumnDataSource est de vous permettre de créer différents graphiques à partir des mêmes données. En bref, il s’agit d’une base de données que vous pouvez réutiliser dans plusieurs graphiques et analyses. Vous gagnez ainsi du temps, sans avoir à recharger vos données plusieurs fois dans Jupyter Notebook.
ColumnDataSource s’apparente à un dictionnaire Python : chaque colonne est accessible via une clé de type chaîne associée à ses valeurs.
Créer des graphiques linéaires avec ColumnDataSource
# Import des packages
from bokeh.io import output_file, show
from bokeh.plotting import figure, ColumnDataSource
# Créer l'objet ColumnDataSource
df_goog['date'] = pd.to_datetime(df_goog['date'])
data = ColumnDataSource(df_goog)
# Créer le graphique en série temporelle
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)
Le graphique montre l’évolution des plus hauts de Google sur cinq ans, la ligne indiquant chaque point de cours.
Pour créer ce graphique, nous avons passé l’intégralité du dataframe de l’action Google à la fonction ColumnDataSource et l’avons enregistré dans une variable nommée data.
Nous avons ensuite utilisé l’argument source pour injecter ces données dans la fonction de tracé. Cela permet d’appeler directement les noms de colonnes lors de la création du graphique, plutôt que d’appeler le dataframe à répétition.
Enfin, nous avons utilisé la fonction line pour générer la ligne verte représentant les points de données.
Créer des nuages de points avec ColumnDataSource
Dans ce code, nous passons l’intégralité du dataframe de l’action Google à ColumnDataSource (comme dans l’exemple de la courbe). Le dataframe est enregistré dans ColumnDataSource sous la variable data. Nous créons d’abord la courbe en appelant directement les noms de colonnes. Enfin, nous utilisons la fonction diamond pour ajouter des losanges rouges représentant chaque point de données.
# Import des packages
from bokeh.io import output_file, show
from bokeh.plotting import figure, ColumnDataSource
# Créer l'objet ColumnDataSource
df_goog['date'] = pd.to_datetime(df_goog['date'])
data = ColumnDataSource(df_goog)
# Créer le graphique en série temporelle
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)
Le graphique montre l’évolution du titre Google sur cinq ans, avec des losanges rouges indiquant chaque point de cours.
Conclusion
Ce tutoriel a présenté les structures de données les plus courantes que vous êtes susceptible de rencontrer en Python et comment les utiliser pour donner vie à vos données. Bokeh n’est pas la seule option de visualisation en Python, mais il se distingue de Matplotlib ou Seaborn par sa simplicité et ses capacités interactives. Dans notre prochain tutoriel, vous passerez à la pratique avec les mises en page pour créer des visualisations efficaces et interactives. Pour explorer en profondeur tout ce que Bokeh permet en matière de visualisation, découvrez le cours Interactive Data Visualization with Bokeh de DataCamp.