Visualisations Python Avancées dans Grist : Graphiques et Dashboards
Introduction
Les visualisations sont essentielles pour transformer vos données brutes en insights actionnables. Avec Python dans Grist, vous pouvez créer des graphiques interactifs et des dashboards sophistiqués qui dépassent largement les capacités natives de Grist.
Prérequis
- Accès aux formules Python dans Grist
- Connaissance de base de Python
- Compréhension des bibliothèques de visualisation
Les Bibliothèques de Visualisation Disponibles
1. Matplotlib - Les Fondamentaux
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('Agg') # Nécessaire pour Grist
# Créer un graphique simple
def create_bar_chart(data):
fig, ax = plt.subplots(figsize=(10, 6))
ax.bar(data.keys(), data.values())
ax.set_title('Ventes par Mois')
ax.set_xlabel('Mois')
ax.set_ylabel('Ventes (€)')
# Sauvegarder en base64 pour affichage
import io
import base64
buf = io.BytesIO()
plt.savefig(buf, format='png', bbox_inches='tight')
buf.seek(0)
img_base64 = base64.b64encode(buf.read()).decode()
plt.close()
return f''2. Plotly - Graphiques Interactifs
import plotly.graph_objects as go
import plotly.express as px
import json
def create_interactive_line_chart(dates, values):
fig = go.Figure()
fig.add_trace(go.Line(x=dates, y=values, mode='lines+markers'))
fig.update_layout(
title='Évolution des Ventes',
xaxis_title='Date',
yaxis_title='Montant (€)',
hovermode='x unified'
)
# Retourner le HTML du graphique
return fig.to_html(include_plotlyjs='cdn', full_html=False)3. Seaborn - Statistiques Avancées
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
def create_correlation_heatmap(dataframe):
plt.figure(figsize=(12, 8))
sns.heatmap(dataframe.corr(), annot=True, cmap='coolwarm', center=0)
plt.title('Matrice de Corrélation')
# Conversion en base64
import io
import base64
buf = io.BytesIO()
plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
buf.seek(0)
img_base64 = base64.b64encode(buf.read()).decode()
plt.close()
return f''Créer un Dashboard Complet
Structure du Dashboard
def create_dashboard(data):
dashboard_html = """
Dashboard Performance
Ventes Mensuelles
{monthly_chart}
Répartition par Catégorie
{category_chart}
Tendances
{trend_chart}
"""
# Générer les graphiques
monthly = create_monthly_chart(data['monthly'])
category = create_pie_chart(data['categories'])
trend = create_trend_line(data['trends'])
return dashboard_html.format(
monthly_chart=monthly,
category_chart=category,
trend_chart=trend
)Intégration dans Grist
Colonne de Type "Card"
Pour afficher vos visualisations :
- Créez une nouvelle colonne
- Définissez le type comme "Card"
- Utilisez une formule Python qui retourne du HTML
Exemple Pratique : KPIs en Temps Réel
# Dans une colonne Python
def generate_kpi_cards():
total_sales = SUM($Sales)
avg_order = AVERAGE($Order_Value)
growth = ($Current_Month - $Previous_Month) / $Previous_Month * 100
return f"""
Ventes Totales
€{total_sales:,.2f}
Panier Moyen
€{avg_order:,.2f}
Croissance
{growth:+.1f}%
"""Graphiques Avancés
Graphique en Bougies (Candlestick)
import plotly.graph_objects as go
def create_candlestick_chart(ohlc_data):
fig = go.Figure(data=[go.Candlestick(
x=ohlc_data['dates'],
open=ohlc_data['open'],
high=ohlc_data['high'],
low=ohlc_data['low'],
close=ohlc_data['close']
)])
fig.update_layout(
title='Analyse des Prix',
yaxis_title='Prix (€)',
xaxis_rangeslider_visible=False
)
return fig.to_html(include_plotlyjs='cdn', full_html=False)Carte Thermique Géographique
import plotly.express as px
def create_choropleth_map(regions_data):
fig = px.choropleth(
regions_data,
locations='code_region',
locationmode='ISO-3166-2',
color='ventes',
color_continuous_scale='Viridis',
scope='europe',
title='Ventes par Région'
)
return fig.to_html(include_plotlyjs='cdn', full_html=False)Performance et Optimisation
Mise en Cache des Graphiques
# Utiliser un dictionnaire pour cacher les résultats
_chart_cache = {}
def get_cached_chart(chart_id, data):
cache_key = f"{chart_id}_{hash(str(data))}"
if cache_key not in _chart_cache:
_chart_cache[cache_key] = create_complex_chart(data)
return _chart_cache[cache_key]Lazy Loading
def generate_lazy_chart(chart_data):
# Générer un placeholder qui charge le vrai graphique
placeholder_id = f"chart_{uuid.uuid4().hex[:8]}"
return f"""
Chargement du graphique...
// Le graphique se charge lorsque visible
loadChartWhenVisible('{placeholder_id}', {chart_data});
"""Cas d'Usage Avancés
Analyse de Sentiment en Temps Réel
from textblob import TextBlob
import plotly.express as px
def analyze_sentiment_dashboard(reviews):
sentiments = [TextBlob(review).sentiment.polarity for review in reviews]
fig = px.histogram(
x=sentiments,
nbins=20,
title='Distribution des Sentiments',
labels={'x': 'Score de Sentiment (-1 à 1)'}
)
return fig.to_html(include_plotlyjs='cdn', full_html=False)Prédictions avec Visualisation
from sklearn.linear_model import LinearRegression
import numpy as np
def create_prediction_chart(historical_data, future_periods=12):
# Entraîner le modèle
X = np.array(range(len(historical_data))).reshape(-1, 1)
y = np.array(historical_data)
model = LinearRegression()
model.fit(X, y)
# Prédire les valeurs futures
future_X = np.array(range(len(historical_data),
len(historical_data) + future_periods)).reshape(-1, 1)
predictions = model.predict(future_X)
# Visualiser
fig = go.Figure()
fig.add_trace(go.Scatter(x=list(range(len(historical_data))),
y=historical_data, name='Historique'))
fig.add_trace(go.Scatter(x=list(range(len(historical_data),
len(historical_data) + future_periods)),
y=predictions, name='Prédictions',
line=dict(dash='dash')))
return fig.to_html(include_plotlyjs='cdn', full_html=False)Meilleures Pratiques
- Optimisez les performances : Limitez la complexité des graphiques pour les grandes datasets
- Responsive Design : Utilisez des unités relatives (%, vw, vh)
- Accessibilité : Ajoutez des textes alternatifs et des descriptions
- Versioning : Gardez une trace des versions de vos visualisations
- Tests : Validez vos graphiques avec différents jeux de données
Conclusion
Python ouvre des possibilités illimitées pour la visualisation de données dans Grist. Des graphiques simples aux dashboards interactifs complets, vous pouvez créer des expériences visuelles riches qui donnent vie à vos données.
Pour aller plus loin, consultez notre Guide Complet Python dans Grist.