Use matplotlib, pandas, and plotly to leverage Python’s power of data visualization. For interactive reading and executing code blocks 
and find b07-pyplot.ipynb or Python (Installation) locally along with JupyterLab.
Outils (paquets) pour Plotting avec Python¶
Plusieurs paquets permettent de tracer dans Python. La dernière page a déjà présenté NumPy et pandas pour tracer des histogrammes. Pandas capacités de complot aller bien au-delà de seulement tracer des histogrammes et il compte sur la puissante matplotlib bibliothèque. SciPy est la bibliothèque la plus populaire de Python (depuis son introduction en 2003) et non seulement pandas, mais aussi d’autres bibliothèques (par exemple la couche d’abstraction Seaborn) utilisent matplotlib avec des commandes facilitées. Cette page présente les paquets suivants pour la visualisation des données:
matplotlib - la base de la visualisation des données en Python
pandas - en tant qu’API d’emballage de matplotlib, avec de nombreuses options simplifiées pour les parcelles significatives
plotly - pour les tracés interactifs, dans lesquels les utilisateurs peuvent changer et déplacer des échelles de tracé
Watch this section as a video
Watch this section as a video on the @Hydro-Morphodynamics channel on YouTube.
Matplotlib¶
En raison de sa complexité et du fait que toutes les fonctions importantes peuvent être utilisées avec pandas de manière beaucoup plus gérable, nous ne discuterons ici que brièvement de matplotlib. Pourtant, il est important de savoir comment matplotlib fonctionne pour mieux comprendre la base de référence du tracé avec Python et pour utiliser des graphiques plus complexes ou des options de tracé plus au besoin.
En 2003, le développement de matplotlib a été initié dans le domaine de la neurobiologie par John D. Hunter (†) pour imiter The MathWorks’ MATLAB® logiciel. Ce développement précoce a constitué le paquet pylab, qui est aujourd’hui obsolète pour sa mauvaise pratique d’écraser Python (en particulier NumPy) plot() et array() methods/objects. Aujourd’hui, il est recommandé d’utiliser:
import matplotlib.pyplot as pltQuelques termes et définitions¶
A plt.figure peut être considéré comme une boîte contenant un ou plusieurs axes, qui représentent les parcelles réelles. Dans les axes, il y a des objets plus petits dans la hiérarchie tels que des marqueurs, des lignes, des légendes et des champs de texte. Presque chaque élément d’un graphique est un attribut manipulable et les attributs les plus importants sont montrés dans la figure suivante. D’autres attributs peuvent être trouvés dans les vitrines de matplotlib.org.
Figure 1:Éléments d’une figure matplotlib.pyplot.
Recette étape par étape pour les lots 1d/2d (ligne)¶
Importer le paquet
pyplotavecimport matplotlib.pyplot as pltCréer une figure avec
plt.figure(figsize=(width_inch, height_inch), dpi=int, facecolor=str, edgecolor=str)Ajouter des axes à la figure avec
axes=fig.add_subplot(row=int, column=int, index=int, label=str)Générer une carte couleur;
plt.cm.getcmap()génère un tableau de couleurs comme expliqué dans le numpy section. Par exemplecolormap=([255, 0, 0])crée une carte couleur avec une seule couleur (rouge).Pour tracer les données avec
les lignes utilisent
axes.plot(x, y, linestyle=str, marker=str, color=Colormap(int), label=str)et beaucoup d’autres**kwargspeuvent être définies (go the matplotlib docs).les points (marqueurs) utilisent
axes.scatter(x, y, MarkerStyle=str, cmap=Colormap, label=str)et beaucoup d’autres**kwargspeuvent être définis (go the matplotlib docs)
Coques de l’axe des manipulations
plt.xticks(list)` # define x-axis ticks plt.yticks(list)` # define y-axis ticks axes.set_xlim(tuple(min, max))` # sets the x-axis minimum and maximum axes.set_ylim(tuple(min, max))` # sets the y-axis minimum and maximum axes.set_xlabel(str)` # sets the x-axis label axes.set_ylabel(str)` # sets the y-axis labelAjouter une légende (facultativement) avec
axes.legend(loc=str, facecolor=str, edgecolor=str, framealpha=float_between_0_and_1)et beaucoup d’autres**kwargspeuvent être définis (voir matplotlib docs).Optionnel : Enregistrer la figure avec
plt.savefig(fname=str, dpi=int)avec beaucoup d’autres**kwargsdisponibles (voir matplotlib docs).
Le bloc de code suivant illustre une recette d’intrigue en utilisant randomement prélevé des échantillons d’une distribution Weibull avec le facteur de forme de distribution (pour a=1, la distribution Weibull réduit à une distribution exponentielle). L’argument seed décrit la source du hasard et seed=None fait Python utiliser le hasard à partir des variables du système d’exploitation.
Le bloc de code ci-dessous utilise une fonction appelée plot_xy qui nécessite des arguments x et y et accepte les arguments optionnels suivants :
plot_type=strdéfinit si une ligne ou un graphique de dispersion doit être produit,label=strdéfinit la légende,save=strdéfinit un chemin où la figure doit être sauvegardée (la figure n’est pas sauvegardée si rien n’est fourni). Pour activer la sauvegarde d’une figure, utilisez l’argument optionnelsave, par exemple,save='C:/temp/weibull.png'sauvegarde la figure dans un dossiertemplocal sur un disque WindowsC:.
import matplotlib.pyplot as plt
import matplotlib.cm as cm
x = np.arange(1, 100)
y = np.random.RandomState(seed=None).weibull(3., len(x))
def plot_xy(x, y, plot_type="1D-line", label="Rnd. Weibull", save=""):
fig = plt.figure(figsize=(6.18, 3.82), dpi=100, facecolor='w', edgecolor='gray') # figsize in inches
axes = fig.add_subplot(1, 1, 1, label=label) # row, column, index, label
colormap = cm.plasma(np.linspace(0, 1, len(y))) # more colormaps: http://matplotlib.org/users/colormaps.html
if plot_type == "1D-line":
ax = axes.plot(x, y, linestyle="-", marker="o", color=colormap[0], label=label) # play with the colormap index
if plot_type == "scatter":
ax = axes.scatter(x, y, marker="x", color=colormap, label=label)
if not "ax" in locals():
print("ERROR: No valid input data provided.")
return -1
plt.xticks(list(np.arange(0, len(x) + 10, (len(x) + 1) / 5.)))
plt.yticks(list(np.arange(0, np.ceil(y.max()), 0.5)))
axes.set_xlim((0,100))
axes.set_ylim((0,2))
axes.set_xlabel("Linear x data")
axes.set_ylabel("Scale of " + str(label))
axes.legend(loc='upper right', facecolor='y', edgecolor='k', framealpha=0.5)
if save:
plt.savefig(save)
print("Plot lines")
plot_xy(x, y)
print("Scatter plot")
plot_xy(x, y, plot_type="scatter", label="Rand. Weibull scattered")Terrains de surface et de contour¶
matplotlib offre plusieurs options pour tracer les données X-Y-Z (2d/3d) comme:
Surface plots with color shades:
axes.plot_surface(X, Y, Z)Contour plots:
axes.contour(X, Y, Z)Contour plots with filled surfaces:
axes.contourf(X, Y, Z)Surface plots with triangulated mesh:
axes.plot_trisurf(X, Y, Z)Three-dimensional scatter plots:
axes.scatter3D(X, Y, Z)Streamplots (e.g., of velocity vectors):
axes.streamplot(X, Y, U, V)Color-coded representation of gridded values with (annotated) heatmaps (e.g., for habitat suitability index maps):
axes.imshow(data, **kwargs)
Cette section présente l’utilisation des streamplots, qui sont un outil utile pour la visualisation des vecteurs de vitesse (champs de débit) dans les rivières (par exemple, produit avec un modèle numérique). Pour générer un streamplot :
Créer une grille
X-Y, par exemple avec le NumPy’smgridmethod:Y, X = np.mgrid[range, range]Attribuer les données de champ de flux (peut être générée artificiellement, par exemple, sous la forme de variables
UetVdans le bloc de code ci-dessous) aux nœuds de grille. Notez que chaque noeud de grille ne peut recevoir qu’une valeur scalaire, qui estvelocity(en fonction des données de champ 2-directionnelles) dans le bloc de code ci-dessous.Générer des chiffres, comme précédemment dans l’exemple de fonction
plot_xy(voir above 1d/2d plot instructions).
Le bloc de code ci-dessous illustre la génération d’un streamplot (adapté du matplotlib docs) et utilise import matplotlib.gridspec pour placer les sous-plots dans la figure.
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
# generate grid
w = 100
Y, X = np.mgrid[-w:w:10j, -w:w:10j] # j creates complex numbers
# calculate U and V vector matrices on the grid
U = -2 - X**2 + Y
V = 0 + X - Y**2
fig = plt.figure(figsize=(6., 2.5), dpi=200)
fig_grid = gridspec.GridSpec(nrows=1, ncols=2)
velocity = np.sqrt(U**2 + V**2) # calculate velocity vector
# Varying line width along a streamline
axes1 = fig.add_subplot(fig_grid[0, 0])
axes1.streamplot(X, Y, U, V, density=0.6, color='b', linewidth=3*velocity/velocity.max())
axes1.set_title('Line width variation', fontfamily='Tahoma', fontsize=8, fontweight='bold')
# Varying color along a streamline
axes2 = fig.add_subplot(fig_grid[0, 1])
uv_stream = axes2.streamplot(X, Y, U, V, color=velocity, linewidth=2, cmap='Blues')
fig.colorbar(uv_stream.lines)
axes2.set_title('Color maps', fontfamily='Tahoma', fontsize=8, fontweight='bold')
plt.tight_layout()
plt.show()Polices et styles¶
L’exemple précédent comportait un ajustement du type de police pour les titres de l’intrigue (axes.set_title('title', font ...)). La police et ses caractéristiques (p. ex. taille, poids, style ou famille) peuvent être définies de façon plus cohérente avec matplotlib.font_manager.FontProperties (cf. le matplotlib docs), où les paramètres de police de l’intrigue peuvent être modifiés globalement dans un script.
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from matplotlib import rc
# create FontProperties object and set font characteristics
font = FontProperties()
font.set_family("sans-serif")
font.set_name("Times New Roman")
font.set_style("italic")
font.set_weight("semibold")
font.set_size(10)
print("Needs to be converted to a dictionary: " + str(font))
# translate FontProperties to a dictionary
font_dict = {"family": "normal"}
for e in str(font).strip(":").split(":"):
if "=" in e:
font_dict.update({e.split("=")[0]: e.split("=")[1]})
# apply font properties to script
rc("font", **font_dict)
# make some plot data
x_lin = np.linspace(0.0, 10.0, 1000) # evenly spaced numbers over a specific interval (start, stop, number-of-elements)
y_osc = np.cos(5 * np.pi * x_lin) * np.exp(-x_lin)
# plot
fig, axes = plt.subplots(figsize=(6.18, 1.8), dpi=150)
axes.plot(x_lin, y_osc, label="Oscillations")
axes.legend()
axes.set_xlabel("Time (s)")
axes.set_ylabel("Oscillation (V)")
plt.tight_layout()
plt.show()Au lieu d’utiliser rc, les caractéristiques de la police peuvent également être mises à jour avec matplotlib rcParams dictionary. En général, tous les paramètres de police peuvent être consultés avec rcParams ainsi que beaucoup d’autres paramètres d’options de mise en page. Les options paramétriques sont stockées dans le fichier matplotlibrc et peuvent être consultées avec rcParams["matplotlibrc-parameter"]. Pour en savoir plus sur les options de modification ("matplotlibrc-parameter") dans le matplotlib docs. Pour modifier un paramètre de style (font) utilisez rcParams.update({parameter-name: parameter-value}) (qui ne fonctionne pas toujours, par exemple, dans jupyter).
De plus, de nombreux styles par défaut sont disponibles par matplotlib.style avec beaucoup de style templates. L’exemple suivant illustre l’application des variables rcParams et style à l’ensemble de données d’oscillation x-y précédemment généré.
from matplotlib import rcParams
from matplotlib import rcParamsDefault
from matplotlib import style
rcParams.update(rcParamsDefault) # reset parameters in case you run this block multiple times
print("Some available serif fonts: " + ", ".join(rcParams['font.serif'][0:5]))
print("Some available sans-serif fonts: " + ", ".join(rcParams['font.sans-serif'][0:5]))
print("Some available monospace fonts: " + ", ".join(rcParams['font.monospace'][0:5]))
print("Some available fantasy fonts: " + ", ".join(rcParams['font.fantasy'][0:5]))
# change rcParams
rcParams.update({'font.fantasy': 'Impact'}) # has no effect here!
print("Some available styles: " + ", ".join(style.available[0:5]))
style.use('seaborn-v0_8-darkgrid')
# plot
fig, axes = plt.subplots(figsize=(6.18, 1.8), dpi=150)
axes.plot(x_lin, y_osc, label="Oscillations")
axes.legend()
axes.set_xlabel("Time (s)")
axes.set_ylabel("Oscillation (V)")
plt.tight_layout()
plt.show()```{image} ../img/python/output_10_1.png
```Couleurs¶
L’utilisation de cartes de couleur est un sujet sensible : souvent par défaut, les palettes arc-en-ciel mapper des teintes distinctes que beaucoup de téléspectateurs avec des déficiences de vision de couleur (environ 1 homme sur 12) ne peuvent pas différencier de façon fiable. Considérez les aspects suivants pour accommoder de façon perceptuelle des plans de couleurs uniformes et respectueux de la couleur :
Séquentiel (faible > élevé): utiliser les séquences de Matplotlib
viridis,magma,plasma,inferno; ou les séquences de domaine-aware de cmocéan (voir aussi ci-dessous) pour utiliser, par exemple,cmo.thermalpour la température,cmo.halinepour la salinité).Divergence (accent sur le point médian): utiliser lorsque les valeurs s’écartent autour d’un centre significatif (0, climatologie, etc.). Exemples : Matplotlib’s
seismic-style mais perceptually accorded options commecoolwarm(toujours imparfaite) ou cmocean’sbalance,delta,curl, qui sont conçus pour le contrôle de la symétrie et de la légèreté.Cyclique (variables d’arrondi): pour phase/aspect (0°) 360°. Utiliser des cartes cycliques telles que
phase.Categorical (classes discrètes): utiliser des palettes distinctes et désaturées avec une bonne séparation de la légèreté; éviter les catégories “rainbow” pour les données quantitatives.
** Gamme dynamique :** s’assurer que la rampe de légèreté couvre la gamme où votre public a besoin de discrimination (vous pouvez couper/cliper la gamme colormap si nécessaire).
Contexte : choisir une carte dont la légèreté contraste avec le fond de la figure (des cartes sombres sur des fonds sombres masquent des valeurs basses).
Pour faciliter le travail avec ces colormaps, envisagez d’installer cmocean:
pip installer cmoceanCi-dessous est un exemple de code pour l’utilisation perceptually uniforme, coloraved-friendly colormaps. Vous pouvez trouver cet exemple dans le chapitre Science Life Hacks.
import matplotlib.pyplot as plt
import numpy as np
import cmocean
# Set a perceptually-uniform default
plt.rcParams["image.cmap"] = "viridis"
# Generate data
x = np.linspace(-3, 3, 400)
y = np.linspace(-3, 3, 400)
X, Y = np.meshgrid(x, y)
Z = np.hypot(X, Y)
# Create sequential perceptually-uniform plot
plt.imshow(Z, origin="lower", cmap=cmocean.cm.thermal)
plt.colorbar(label="Temperature-like quantity")
plt.title("Sequential, perceptually-uniform")
plt.show()Annotations¶
Il est parfois utile de souligner les particularités des graphiques pour expliquer ou nommer les observations sur les graphiques. Le bloc de code suivant montre certaines options avec auto-explication chaînes.
from matplotlib import rcParams
from matplotlib import rcParamsDefault
from matplotlib import style
rcParams.update(rcParamsDefault) # reset parameters in case you run this block multiple times
fig, axes = plt.subplots(figsize=(10, 2.5), dpi=150)
style.use('fivethirtyeight') # let s just use still another style
fig.suptitle('This is the figure (super) title', fontsize=8, fontweight='bold')
axes.set_title('This is the axes (sub) title', fontsize=8)
axes.text(1, 0.8, 'B-boxed italic text with axis coords 1, 0.8', style='italic', fontsize=8, bbox={'facecolor': 'green', 'alpha': 0.5, 'pad': 5})
axes.text(5, 0.6, r'Annotation text with equation: $u=U^2 + V^2$', fontsize=8)
axes.text(7, 0.2, 'Color text with axis coords (7, 0.2)', verticalalignment='bottom', horizontalalignment='left', color='red', fontsize=8)
axes.plot([0.5], [0.2], 'x', markersize=7, color='blue') #plot an arbitrary point
axes.annotate('Annotated point', xy=(0.5, 0.2), xytext=(2, 0.4), fontsize=8, arrowprops=dict(facecolor='blue', shrink=0.05))
axes.axis([0, 10, 0, 1]) # x_min, x_max, y_min, y_max
plt.show()Plottage avec Pandas¶
Plotting with matplotlib can be daunting, not because the library is poorly documented (the complete opposite is the case), but because matplotlib is very extensive. pandas brings remedy with simplified commands for high-quality plots. The simplest way to plot a pandas DataFrame is pd.DataFrame.plot(x="col1", y="col2"). The following example illustrates this fundamentally simple usage with a river discharge series stored in a workbook (download example_flow_gauge.xlsx).
flow_df = pd.read_excel('data/example_flow_gauge.xlsx', sheet_name='Mean Monthly CMS')
print(flow_df.head(3))
flow_df.plot(x="Date (mmm-jj)", y="Flow (CMS)", kind='line')
Pandas et Matplotlib¶
Parce que pandas tracent les racines de la fonctionnalité dans la bibliothèque matplotlib, ceux-ci peuvent être facilement combinés, par exemple, pour créer des sous-plots:
import matplotlib.pyplot as plt
from matplotlib import cm
flow_ex_df = pd.read_excel('data/example_flow_gauge.xlsx', sheet_name='FlowDuration')
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 2.5), dpi=150)
flow_ex_df.plot(x="Relative exceedance", y="Flow (CMS)", kind='area', color='DarkBlue', grid=True, title="Blue area plot", ax=axes[0])
flow_ex_df.plot(x="Relative exceedance", y="Flow (CMS)", kind='scatter', color="DarkGreen", title="Green scatter", marker="x", ax=axes[1])Boxplots et barres d’erreur¶
Une box-plot représente graphiquement la distribution de la diffusion (statistique) et des paramètres d’une série de données.
Pourquoi utiliser une boîte avec un cadre de données pandas ? La raison en est qu’avec les cadres de données pandas, nous chargeons généralement des séries de données avec des propriétés statistiques par colonne. Par exemple, si nous effectuons une expérience de débit constant dans un labo hydraulique avec des sondes ultrasoniques pour obtenir des profondeurs d’eau, nous observerons des fluctuations de signal, même si le débit était stable. En chargeant les données de signal dans un cadre de données pandas, nous pouvons utiliser un diagramme de boîte pour observer la profondeur moyenne d’eau et le bruit dans la mesure entre différentes sondes. Ainsi, les sondes à bruit inattendu peuvent être identifiées et réparées. Ce petit exemple peut être appliqué à plus grande échelle à de nombreux autres capteurs et à bien d’autres fins (le bruit ne signifie pas toujours qu’un capteur est brisé). Un box-plot possède les attributs suivants:
boîtes représentent le corps principal des données avec des quartiles et des intervalles de confiance autour de la médiane (si activé).
medians sont des lignes horizontales à la médiane (visuellement au milieu) de chaque boîte.
whiskers sont des lignes verticales qui s’étendent jusqu’aux points de données les plus extrêmes et les plus éloignés.
caps sont de petites extrémités horizontales de la ligne des moustaches.
Les bouteilles sont des points plus aberrants que les moustaches.
moyens sont soit des points, soit des lignes de données.
pandas data frames make use of matplotlibdf.boxplot() or df.plot.box(). The following example features box-plots of water depth measurements with ultrasonic probes (sensors 1, 2, 3, and 5) stored in FlowDepth009.csv (download).
us_sensor_df = pd.read_csv("data/FlowDepth009.csv", index_col=0, usecols=[0, 1, 2, 3, 5])
print(us_sensor_df.head(2))
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 2.5), dpi=150)
fontsize = 8.0
labels = ["S1", "S2", "S3", "S5"]
# make plot props dicts
diamond_fliers = dict(markerfacecolor='thistle', marker='D', markersize=2, linestyle=None)
square_fliers = dict(markerfacecolor='aquamarine', marker='+', markersize=3)
capprops = dict(color='deepskyblue', linestyle='-')
medianprops = {'color': 'purple', 'linewidth': 2}
boxprops = {'color': 'palevioletred', 'linestyle': '-'}
whiskerprops = {'color': 'darkcyan', 'linestyle': ':'}
us_sensor_df = us_sensor_df.rename(columns=dict(zip(list(us_sensor_df.columns), labels))) # rename for plot conciseness
us_sensor_df.boxplot(fontsize=fontsize, ax=axes[0], labels=labels, widths=0.25, flierprops=diamond_fliers,
capprops=capprops, medianprops=medianprops, boxprops=boxprops, whiskerprops=whiskerprops)
us_sensor_df.plot.box(color="tomato", vert=False, title="Hz. box-plot", flierprops=square_fliers,
whis=0.75, fontsize=fontsize, meanline=True, showmeans=True, ax=axes[1], labels=labels)Box-plots represent the statistical assets of datasets, but box-plots can quickly become confusing (messy) when they are presented in technical reports for multiple measurement series. Yet, it is state-of-the-art and good practice to present uncertainties in datasets in scientific and non-scientific publications, but somewhat more easily than, for example, with box-plots. To this end, so-called error bars can be added to data bars. Error bars graphically express the uncertainty of a data set simply, by displaying only whiskers. Regardless of whether scatter or bar plot, error bars can easily be added to graphics through matplotlib (more in the docs). The following example shows the application of error bars to bar plots of the above ultrasonic sensor data.
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 2.5), dpi=150)
# calculate stats
means = us_sensor_df.mean()
errors = us_sensor_df.std()
# make error bar bar plots
means.plot.bar(yerr=errors, capsize=4, color='palegreen', title="Error bars", width=0.3, fontsize=fontsize, ax=axes[0])
means.plot.barh(xerr=errors, capsize=5, color="lightsteelblue", title="Horizontal error bars", fontsize=fontsize, ax=axes[1])
D’autres options pour la visualisation d’un cadre de données pandas sont fournies dans le pandas visualization docs. Gardez à l’esprit que matplotlib peut toujours être appliqué sur une parcelle de pandas.
Lots interactifs avec parcelle¶
Les paquets de matplotlib et pandas ci-dessus montrés sont parfaits pour créer des graphiques statiques dans un environnement de bureau, de rapport ou de papier. Bien que des tracés interactifs pour des présentations web puissent être créés avec matplotlib (en savoir plus dans le matplotlib docs), la bibliothèque plotly utilise de nombreuses options de tracé web plus interactives dans une API facile à utiliser. Plotly peut également gérer des données comme JSON (hébergé quelque part sur Internet) pour créer des applications web avec Dash. Un seul problème : l’entreprise derrière le complot est axée sur les affaires.
Watch this section as a video
Watch this section on plotly as a video on the @Hydro-Morphodynamics channel on YouTube.
Installation¶
Plotly n’est pas un paquet par défaut ni dans le fichier d’environnement flusstools (environment.yml), ni dans l’environnement conda base. Par conséquent, il doit être installé manuellement avec conda prompt (ou Conda Navigator si vous préférez la version Desktop). Par conséquent, pour utilisation avec Jupyter, ouvrez conda prompt pour installer plotly pour:
utilisation de juspyter* et environnement de conda:
conda install plotly(confirmer l’installation lorsqu’elle est demandée)
jupyter labextension install jupyterlab-plotly@4.11.0(changer la version4.11.0à la dernière version listée here)
optional:conda install -c plotly chart-studio(bien pour les autres parcelles que figurant sur cette page)
jupyter usage in a virtual environment:
pip install plotly
Pour le dépannage, visitez le site web du développeur et corrigez les problèmes avec Jupyter ou Python (il peut y en avoir...).
Pour installer plotly dans flussenv (p. ex. pour utilisation avec Jupyter, PyCharm ou VS Code) utiliser soit :
Un environnement conda (recall installation instructions):
conda activate flussenvconda install plotly(confirmer l’installation sur demande)conda install "notebook>=5.3" "ipywidgets>=7.2"
a pip environment (recall installation instructions):
source vflussenv/bin/activatepip install plotly
Pour en savoir plus sur l’installation de paquets à conda environmen ou pip environment.
Utilisation (plots simples)¶
Plotly est livré avec des ensembles de données qui peuvent être interrogés en ligne pour les vitrines. L’exemple suivant utilise l’un de ces ensembles de données (en savoir plus à plotly.com).
import plotly.express as px
import plotly.graph_objects as go
import plotly.offline as pyo
pyo.init_notebook_mode()
df = px.data.gapminder().query("continent=='Europe'")
fig = px.line(df, x="year", y="pop", color='country')
fig.show()
pyo.iplot(fig, filename='population')Dans l’hydraulique, nous préférons souvent visualiser les données dans les fichiers texte stockés localement, par exemple, après traitement de la sortie de la modélisation numérique 2d avec NumPy ou pandas. Plotly fonctionne main dans la main avec pandas et l’exemple suivant dispose de tracer pandas data frames, construire à partir d’un fichier csv avec ploty (de meilleures solutions pour pandas data frame tri sont affichées dans le pandas reshaping section). L’exemple suivant utilise plotly.offline pour tracer des données en mode portable (pyo.init_notebook_mode()) et pyo.iplot() peut être utilisé pour écrire des fonctions de tracé à un script vivant localement pour tracer interactif (télécharger temperature change.csv).
import plotly.graph_objects as go
import plotly.offline as pyo
import pandas as pd
pyo.init_notebook_mode() # activate to create local function script
df = pd.read_csv("data/temperature_change.csv")
# filter dataframe by country and month
country_filter = "France" # available in the csv: Austria, Belgium, Finland, France, Germany
month_filter1 = "January"
month_filter2 = "July"
df_country = df[df.Area == country_filter]
df_country_month1 = df[df.Months == month_filter1]
df_country_month2 = df[df.Months == month_filter2]
# define plot type = go.Bar
bar_plots = [go.Bar(x=df_country_month1["Year"], y=df_country_month1["Value"], name=str(month_filter1), marker=go.bar.Marker(color='#86DCEB')),
go.Bar(x=df_country_month2["Year"], y=df_country_month2["Value"], name=str(month_filter2), marker=go.bar.Marker(color='#EA9285'))]
# set layout
layout = go.Layout(title=go.layout.Title(text="Monthly average surface temperature deviation (ref. 1951-1980) in " + str(country_filter), x=0.5),
yaxis_title="Temperature (°C)")
fig = go.Figure(data=bar_plots, layout=layout)
# In local IDE use fig.show() - use iplot(fig) to procude local script for running figure functions
# fig.show(filename='basic-line2', include_plotlyjs=False, output_type='div')
pyo.iplot(fig, filename='temperature-evolution')Demandes de cartes interactives¶
Plotly utilise le format de données GeoJSON (un standard ouvert pour les objets géospatials simples) dans des cartes interactives. Les développeurs fournissent de nombreux exemples dans leur documentation et le bloc de code ci-dessous reproduit une carte représentant les taux de chômage aux États-Unis. D’autres exemples sont disponibles sur le site Web du développeur.
import plotly.offline as pyo
from urllib.request import urlopen
import json
import pandas as pd
pyo.init_notebook_mode() # only necessary in jupyter
with urlopen('https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json') as response:
counties = json.load(response)
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/fips-unemp-16.csv", dtype={"fips": str})
import plotly.express as px
fig = px.choropleth_map(df, geojson=counties, locations='fips', color='unemp',
color_continuous_scale="Viridis",
range_color=(0, 12),
map_style="carto-positron",
zoom=2, center = {"lat": 35.0, "lon": -90.0},
opacity=0.5,
labels={'unemp':'Unemployment rate (%)'}
)
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
fig.show()Beaucoup plus de cartes sont disponibles - certaines d’entre elles nécessitent un compte Mapbox et la création d’un jeton public (lire plus à plotly.com).
Vérification de la réussite en apprentissage¶
Prenez le test de réussite d’apprentissage pour ce carnet Jupyter.
Unfold QR Code
