Visualisation de données Dash avec intégration Plotly
Dans le domaine de la science des données et de l'analyse, la visualisation de données est un élément crucial. Grâce à la visualisation, nous pouvons comprendre les données de manière plus intuitive et découvrir les motifs et tendances qu'elles contiennent.
Les capacités de visualisation principales de Dash reposent sur Plotly, une puissante bibliothèque de visualisation de données open source. Plotly offre une riche variété de types de graphiques et des options hautement personnalisables, ce qui facilite la création de graphiques interactifs.
Dash s'intègre de manière transparente à Plotly via le composant dcc.Graph, permettant aux utilisateurs d'incorporer directement des graphiques Plotly dans les applications Dash.
Qu'est-ce que Plotly ?
Plotly est une bibliothèque de visualisation de données open source basée sur JavaScript qui prend en charge plusieurs langages de programmation, notamment Python, R, Julia, et d'autres.
Plotly propose une large gamme de types de graphiques, tels que des graphiques en courbes, des graphiques à barres, des nuages de points, des cartes thermiques, et bien plus encore, ainsi que des fonctionnalités interactives telles que le zoom, le déplacement et les infobulles au survol.
Fonctionnalités de Plotly :
Richesse des types de graphiques: Graphiques en courbes, graphiques à barres, nuages de points, diagrammes circulaires, cartes thermiques, graphiques 3D, et plus encore.
interactivité: Prend en charge des fonctionnalités interactives telles que le zoom, le déplacement et les infobulles au survol.
Hautement personnalisable: Permet de personnaliser les couleurs des graphiques, la mise en page, les annotations, et plus encore.
Intégration transparente avec Dash: via
dcc.GraphLe composant intègre directement des graphiques Plotly dans les applications Dash.
Principaux avantages de Plotly
- interactivité: Les graphiques Plotly prennent en charge de riches fonctionnalités interactives, permettant aux utilisateurs d'interagir avec les graphiques via des opérations à la souris.
- diversité: Plotly propose différents types de graphiques adaptés à différents besoins de visualisation de données.
- facilité d'utilisation: La conception de l'API de Plotly est concise et facile à prendre en main, tout en prenant en charge une personnalisation avancée.
Intégration de Dash et Plotly
1. Installer Dash et Plotly
Avant de commencer, nous devons installer Dash et Plotly. Cela peut se faire à l'aide des commandes suivantes :
pip install dash plotly 或 pip3 install dash plotly
dcc.GraphIl s'agit d'un composant dans Dash utilisé pour afficher des graphiques Plotly. Son paramètre principal est figure, qui spécifie les données et la mise en page du graphique.
paramètres de figure :
data: La partie data du graphique, qui est une liste de dictionnaires, où chaque dictionnaire représente une série de données.layout: La partie layout du graphique, utilisée pour définir le titre, les axes, la légende, etc.
Exemple
from dash import dcc, html
import plotly.express as px
# Créer l'application Dash
app = dash.Dash(__name__)
# Définir la mise en page
app.layout = html.Div([
dcc.Graph(
id='example-graph',
figure={
'data': [{'x': [1, 2, 3], 'y': [4, 1, 2], 'type': 'bar', 'name': 'Données 1'}],
'layout': {'title': 'Graphique d'exemple'}
}
)
])
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
L'effet d'affichage est le suivant :

2. Créer une application Dash simple
Tout d'abord, nous créons une application Dash simple qui affiche un graphique Plotly de base.
Exemple
from dash import dcc, html
import plotly.express as px
import pandas as pd
# Créer un jeu de données d'exemple
df = pd.DataFrame({
"Fruit": ["Pommes", "Oranges", "Bananes", "Pommes", "Oranges", "Bananes"],
"Montant": [4, 1, 2, 2, 4, 5],
"Ville": ["SF", "SF", "SF", "NYC", "NYC", "NYC"]
})
# Créer un graphique Plotly
fig = px.bar(df, x="Fruit", y="Amount", color="City", barmode="group")
# Initialiser l'application Dash
app = dash.Dash(__name__)
# Définir la mise en page de l'application
app.layout = html.Div(children=[
html.H1(children='Hello Dash'),
html.Div(children='''
Dash : un framework d'application web pour Python.
'''),
dcc.Graph(
id='example-graph',
figure=fig
)
])
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Analyse du code :
- Création de jeu de données: Nous utilisons
pandasCréation d'un jeu de données simpledf, contenant des informations sur les fruits, la quantité et la ville. - Création de graphique: Utilisez
plotly.expressdepx.barLa fonction crée un diagramme à barres montrant les quantités de divers fruits dans différentes villes. - Mise en page de l'application Dash: Utilisez
html.Divetdcc.GraphDéfini la mise en page de l'application, dans laquelledcc.GraphUtilisé pour intégrer des graphiques Plotly. - Exécuter l'application: Via
app.run_server(debug=True)Démarrez l'application et activez le mode débogage.
L'effet d'affichage est le suivant :

3. Ajouter une fonctionnalité interactive
La puissance de Dash réside dans ses fonctionnalités interactives ; nous pouvons mettre à jour dynamiquement le contenu des graphiques grâce au mécanisme de rappel de Dash.
Exemple
# Mettre à jour la mise en page de l'application pour ajouter un menu déroulant
app.layout = html.Div(children=[
html.H1(children='Hello Dash'),
html.Div(children='''
Dash : un framework d'application web pour Python.
'''),
dcc.Dropdown(
id='city-dropdown',
options=[
{'label': 'San Francisco', 'value': 'SF'},
{'label': 'New York City', 'value': 'NYC'}
],
value='SF'
),
dcc.Graph(
id='example-graph',
)
])
# Définir la fonction de rappel
@app.callback(
Output('example-graph', 'figure'),
[Input('city-dropdown', 'value')]
)
def update_graph(selected_city):
filtered_df = df[df['City'] == selected_city]
fig = px.bar(filtered_df, x="Fruit", y="Amount", color="City", barmode="group")
return fig
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Analyse du code :
- menu déroulant: Ajout d’un
dcc.DropdownComposant, les utilisateurs peuvent sélectionner différentes villes. - fonction de rappel: Utilisez
@app.callbackLe décorateur définit une fonction de rappelupdate_graph, lorsque l’utilisateur sélectionne une autre ville, le graphique se met à jour dynamiquement. - Mise à jour du graphique: La fonction de rappel filtre le jeu de données en fonction de la ville sélectionnée par l’utilisateur et met à jour le graphique.
L'effet d'affichage est le suivant :

Plotly Express
Plotly Express est l'interface de haut niveau de Plotly, capable de créer des graphiques complexes avec un minimum de code. Il est bien adapté au prototypage rapide.
Types de graphiques courants
1. Graphique linéaire (px.line):
import plotly.express as px df = px.data.iris() fig = px.line(df, x='sepal_width', y='sepal_length', title='折线图示例')
2. Diagramme à barres (px.bar):
fig = px.bar(df, x='species', y='sepal_length', title='柱状图示例')
3. Nuage de points (px.scatter):
fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species', title='散点图示例')
4. Diagramme circulaire (px.pie):
fig = px.pie(df, names='species', values='sepal_length', title='饼图示例')
5. Carte thermique (px.imshow):
import numpy as np data = np.random.rand(10, 10) fig = px.imshow(data, title='热力图示例')
L'exemple suivant est une application Dash complète qui utilise Plotly Express pour créer des graphiques :
Exemple
import plotly.express as px
import pandas as pd
# Créer des données d'exemple
df = pd.DataFrame({
'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
'Population': [2171, 2424, 1490, 1303]
})
# Créer l'application Dash
app = Dash(__name__)
# Utiliser Plotly Express pour créer un diagramme à barres
fig = px.bar(df, x='city', y='Population', title=Données de population de la ville)
# Définir la mise en page
app.layout = html.Div([
dcc.Graph(id='example-graph', figure=fig)
])
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Affiché comme suit :

Utilisation de Plotly Graph Objects
Plotly Graph Objects est l'interface de bas niveau de Plotly, offrant un contrôle plus granulaire et adapté aux scénarios nécessitant un haut degré de personnalisation.
Types de graphiques courants
1. Graphique en courbes (go.Scatter) :
import plotly.graph_objects as go fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 1, 2], mode='lines'))
2. Diagramme à barres (go.Bar) :
fig = go.Figure(data=go.Bar(x=['A', 'B', 'C'], y=[10, 20, 30]))
3. Nuage de points (go.Scatter) :
fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 1, 2], mode='markers'))
4. Diagramme circulaire (go.Pie) :
fig = go.Figure(data=go.Pie(labels=['A', 'B', 'C'], values=[10, 20, 30]))
L'exemple suivant est une application Dash complète qui utilise Plotly Graph Objects pour créer des graphiques :
Exemple
import plotly.graph_objects as go
# Créer l'application Dash
app = Dash(__name__)
# Utilisation de Plotly Graph Objects pour créer des diagrammes à barres
fig = go.Figure(data=go.Bar(x=['Pékin', 'Shanghai', 'Canton', 'Shenzhen'], y=[2171, 2424, 1490, 1303]))
# Définir la mise en page du graphique
fig.update_layout(title=Données de population des villes, xaxis_title='ville', yaxis_title='Population')
# Définir la mise en page
app.layout = html.Div([
dcc.Graph(id='example-graph', figure=fig)
])
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Affiché comme suit :
