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.
Werkzeuge (Packages) für Plotting mit Python¶
Mehrere Pakete ermöglichen das Plotten in Python. Die letzte Seite stellte bereits NumPy und pandas für die Erstellung von Histogrammen vor. pandas-Plotting-Kapazitäten gehen weit über nur Histogramme hinaus und sie setzt auf die mächtige matplotlibBibliothek. SciPy’s matplotlib ist die beliebteste Plotting-Bibliothek in Python (seit seiner Einführung im Jahr 2003) und nicht nur pandas, sondern auch andere Bibliotheken (z.B. die Abstraktionsschicht Seaborn) verwenden matplotlib mit erleichterten Befehlen. Diese Seite führt folgende Pakete zur Datenvisualisierung ein:
matplotlib - die Basis für die Datenvisualisierung in Python
pandas - als Wrapper API von matplotlib, mit vielen vereinfachten Optionen für sinnvolle Handlungen
plotly - für interaktive Plots, in denen die Benutzer die Plot-Skalen ändern und verschieben können
Watch this section as a video
Watch this section as a video on the @Hydro-Morphodynamics channel on YouTube.
Matplotlib¶
Aufgrund seiner Komplexität und der Tatsache, dass alle wichtigen Funktionen mit pandas in viel überschaubarer Weise genutzt werden können, werden wir hier nur kurz matplotlib diskutieren. Dennoch ist es wichtig zu wissen, wie matplotlib arbeitet, um die Grundlinie der Plotting mit Python besser zu verstehen und komplexere Grafiken oder mehr Plotting-Optionen bei Bedarf zu verwenden.
2003 wurde die Entwicklung von matplotlib im Bereich der Neurobiologie von John D. Hunter (†) um The MathWorks’ MATLAB® Software zu emulieren initiiert. Diese frühe Entwicklung bildete das Paket pylab, das heute wegen seiner schlechten Praxis des Überschreibens von Python (insbesondere NumPy) plot() und array()-Methoden/Objekten abgeschrieben wird. Heute wird empfohlen, zu verwenden:
import matplotlib.pyplot as pltEinige Begriffe und Definitionen¶
Ein plt.figure kann als Box mit einer oder mehreren Achsen gedacht werden, die die tatsächlichen Grundstücke darstellen. Innerhalb der Achsen gibt es kleinere Objekte in der Hierarchie wie Marker, Linien, Legenden und Textfelder. Fast jedes Element eines Grundstücks ist ein manipulierbares Attribut und die wichtigsten Attribute sind in der folgenden Abbildung dargestellt. Weitere Attribute finden Sie in den Vitrinen von matplotlib.org.
Figure 1:Elemente einer matplotlib.pyplot.figure.
Schritt für Schritt Rezept für 1d/2d (line) Plots¶
Import matplolib’s
pyplotPaket mitimport matplotlib.pyplot as pltGestalten Sie eine Figur mit
plt.figure(figsize=(width_inch, height_inch), dpi=int, facecolor=str, edgecolor=str)Äxt mit
axes=fig.add_subplot(row=int, column=int, index=int, label=str)Generieren Sie eine Farbkarte;
plt.cm.getcmap()erzeugt eine Reihe von Farben, wie in der numpy section. Beispielsweise erstelltcolormap=([255, 0, 0])eine Farbkarte mit nur einer Farbe (rot).Die Daten mit
Zeilen verwenden
axes.plot(x, y, linestyle=str, marker=str, color=Colormap(int), label=str)und vieles mehr**kwargskann definiert werden (go the matplotlib docs).Punkte (Marker) verwenden
axes.scatter(x, y, MarkerStyle=str, cmap=Colormap, label=str)und vieles mehr**kwargskann definiert werden (go the matplotlib docs)
Manipulation Achse Zecken
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 labelFügen Sie eine Legende (optional) mit
axes.legend(loc=str, facecolor=str, edgecolor=str, framealpha=float_between_0_and_1)hinzu und viele weitere**kwargskönnen definiert werden (siehe matplotlib docs).Optional: Speichern Sie die Zahl mit
plt.savefig(fname=str, dpi=int)mit vielen weiteren**kwargs(siehe matplotlib docs).
Der folgende Codeblock zeigt ein Plotrezept mit zufällig gezeichneten Proben aus einer Weibull Distribution mit dem Distributionsformfaktor (für a=1, die Weibull Distribution reduziert sich auf eine exponentielle Verteilung). Das seed-Argument beschreibt die zufällige Quelle und seed=None macht Python aus Betriebssystemvariablen zufällig.
Der untenstehende Codeblock nutzt eine Funktion namens plot_xy, die x und y Argumente erfordert und akzeptiert die folgenden optionalen Keyword-Argumente:
plot_type=strdefiniert, ob eine Zeile oder ein Streufeld erzeugt werden soll,label=strsetzt die Legende,save=strdefiniert einen Pfad, in dem die Zahl gespeichert werden soll (die Zahl wird nicht gespeichert, wenn nichts bereitgestellt wird). Um eine Figur zu speichern, verwenden Sie das optionale Keyword-Argumentsave, z.B.save='C:/temp/weibull.png', speichert die Figur auf einem WindowsC:-Laufwerk an einen lokalentemp-Ordner.
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")Oberflächen- und Contour-Plots¶
matplotlib bietet mehrere Optionen, um X-Y-Z (2d/3d) Daten wie:
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)
Dieser Abschnitt zeigt die Verwendung von Streamplots, die ein nützliches Werkzeug für die Visualisierung von Geschwindigkeitsvektoren (Flussfelder) in Flüssen (z.B. mit einem numerischen Modell) sind. Um ein Streamplot zu erzeugen:
Erstellen Sie ein
X-YGrid, z.B. mit dem NumPy’smgridmethod:Y, X = np.mgrid[range, range]Den Netzknoten können Stream-Felddaten (z.B. in Form von
UundVVariablen im folgenden Codeblock) künstlich generiert werden. Beachten Sie, dass jeder Netzknoten nur einen Skalarwert zugewiesen bekommen kann, dervelocity(in Abhängigkeit von den 2-direktionalen Felddaten) im folgenden Codeblock ist.Generieren Sie Zahlen wie zuvor im
plot_xyFunktionsbeispiel (siehe above 1d/2d plot instructions).
Der folgende Codeblock zeigt die Erzeugung eines Streamplots (angepasst von matplotlib docs) und verwendet import matplotlib.gridspec, um die Subplots in der Figur zu platzieren.
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()Schriften und Stile¶
Das vorangegangene Beispiel beinhaltete eine Schriftartanpassung für die Plottitel (axes.set_title('title', font ...)). Die Schriftart und ihre Eigenschaften (z.B. Größe, Gewicht, Stil oder Familie) können kohärenter mit matplotlib.font_manager.FontProperties(vgl. matplotlib docs) definiert werden, wo Schriftarteneinstellungen in einem Skript global verändert werden können.
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()Anstelle von rc können Schriftmerkmale auch mit matplotlibs rcParams dictionary aktualisiert werden. Im Allgemeinen können alle Schriftparameter mit rcParams zusammen mit vielen weiteren Parametern der Layoutoptionen aufgerufen werden. Die parametrischen Optionen werden in der Datei matplotlibrc gespeichert und können mit rcParams["matplotlibrc-parameter"] aufgerufen werden. Lesen Sie mehr über Modifizierungsoptionen ("matplotlibrc-parameter") in der matplotlib docs. Um einen (Font-)Style-Parameter zu ändern, verwenden Sie rcParams.update({parameter-name: parameter-value}) (was nicht immer funktioniert, zum Beispiel in jupyter).
Darüber hinaus sind viele Standard-Plot-Stile über matplotlib.style mit vielen style templates. Das folgende Beispiel veranschaulicht die Anwendung von rcParams und stylevariablen auf den zuvor generierten x-y-Schwingdatensatz.
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
```Farben¶
Die Verwendung von Farbkarten ist ein sensibles Thema: oft voreingestellte Regenbogenpaletten weisen deutliche Farbtöne auf, die viele Zuschauer mit farblich bedingten Mängeln (ca. 1 bei 12 Männern) nicht zuverlässig unterscheiden können. Betrachten Sie die folgenden Aspekte, um wahrnehmbar einheitliche, colorblind-freundliche Farbkarten aufzunehmen:
*Sequential (niedrig > high): Verwenden Sie Matplotlibs
viridis,magma,plasma,infernooder Domain-Aware-Sequenzen aus cmocean (siehe auch unten), um beispielsweisecmo.thermalfür Temperatur,cmo.halinefür Salinity zu verwenden.*Diverging (Midpoint Betonung): verwenden, wenn Werte um ein aussagekräftiges Zentrum (0, Klimatologie usw.) abweichen. Beispiele: Matplotlibs
seismic-style, aber perzeptuell abgestimmt Optionen wiecoolwarm(noch unperfekt) oder cmoceansbalance,delta,curl, die für Symmetrie und Leichtigkeitskontrolle entwickelt sind.Cyclic (Wrap-around-Variablen): für Phase/Aspekt (0°=360°). Verwenden Sie zyklische Karten wie cmoceans
phase.*Kategorisch (Discrete-Klassen): Verwenden Sie verschiedene, deaturierte Paletten mit guter Leichtigkeitstrennung; vermeiden Sie “Regenbogen”-Kategorien für quantitative Daten.
** Dynamische Reichweite:** sorgen dafür, dass die Leichtigkeitsrampe den Bereich überspannt, in dem Ihr Publikum Diskriminierung braucht (bei Bedarf können Sie den Farbkartenbereich trimmen/clipen).
Background: Wählen Sie eine Karte aus, deren Helligkeit mit dem Abbildungshintergrund kontrast (dunkle Karten auf dunklen Hintergründen obskurieren niedrige Werte).
Um die Arbeit mit solchen Farbkarten zu erleichtern, sollten Sie cmocean:
pip install cmoceanUnten ist ein Beispiel von Code für die Verwendung von wahrnehmbar einheitlichen, colorblind-freundlichen Farbkarten. Dieses Beispiel finden Sie im Kapitel 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()Anmerkungen¶
Die Angabe von Besonderheiten in Graphen ist manchmal hilfreich, um Beobachtungen auf Graphen zu erklären oder zu nennen. Der folgende Codeblock zeigt einige Optionen mit selbsterklärenden strings.
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()Plotting mit 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 und Matplotlib¶
Da pandas-Plot-Funktionalitätswurzeln in der Matplotlib-Bibliothek, können diese leicht kombiniert werden, zum Beispiel, um Subplots zu erstellen:
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 und Error Bars¶
Eine box-plot steht grafisch für die Verteilung der (statistischen) Streuung und Parameter einer Datenreihe.
Warum eine Box-Plotte mit einem pandas Datenrahmen verwenden? Der Grund ist, dass wir mit pandas Datenrahmen typischerweise Datenreihen mit per-column statistischen Eigenschaften laden. Wenn wir zum Beispiel in einem hydraulischen Labor ein stetiges Experiment führen, das mit Ultraschallsonden zur Ableitung von Wassertiefen flieht, werden wir die Signalfluktuation beobachten, obwohl der Fluss stabil war. Durch das Laden der Signaldaten in einen pandas Datenrahmen können wir ein Felddiagramm verwenden, um die durchschnittliche Wassertiefe und das Rauschen in der Messung unter verschiedenen Sonden zu beobachten. So können Sonden mit unerwartetem Rauschen identifiziert und repariert werden. Dieses kleine Beispiel kann auf breiterem Maßstab auf viele andere Sensoren und für viele andere Zwecke angewendet werden (Rausch bedeutet nicht immer, dass ein Sensor gebrochen ist). Ein Box-plot hat die folgenden Attribute:
boxen stellen den Hauptkörper der Daten mit Quartilen und Konfidenzintervallen rund um den Median dar (falls aktiviert).
Median sind horizontale Linien an der Median (visuell in der Mitte) jeder Box.
whiskers sind vertikale Linien, die sich auf die extremsten, nicht-ausreichenden Datenpunkte erstrecken.
caps sind kleine horizontale Linienenden von Whiskers.
Flügel sind überflüssige Punkte hinaus.
Mittel sind entweder Punkte oder Zeilen von Datensatzmitteln.
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 repräsentieren die statistischen Vermögenswerte von Datensätzen, aber Box-plots können schnell verwirrend (Nachricht), wenn sie in technischen Berichten für mehrere Messreihen dargestellt werden. Dennoch ist es hochmoderne und gute Praxis, Unsicherheiten in Datensätzen in wissenschaftlichen und nichtwissenschaftlichen Publikationen zu präsentieren, aber etwas einfacher als zum Beispiel bei Box-Plotten. Zu diesem Zweck können so genannte error bar an Datenbars hinzugefügt werden. Fehlerleisten drücken die Unsicherheit eines Datensatzes einfach grafisch aus, indem nur Whisker angezeigt werden. Unabhängig davon, ob Scatter oder Bar-Plot, können Fehler-Bars leicht zu Grafiken über matplotlib hinzugefügt werden (mehr in the docs). Das folgende Beispiel zeigt die Anwendung von Fehlerleisten auf Balkendiagramme der obigen Ultraschallsensordaten.
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])
Weitere Möglichkeiten zur Visualisierung eines Pandas-Datenrahmens finden Sie im pandas visualization docs. Denken Sie daran, dass matplotlib immer auf einem Pandas-Plot angewendet werden kann.
Interaktive Plots mit Plotly¶
Die oben gezeigten Matplotlib- und Pandas-Pakete eignen sich hervorragend zur Erstellung von statischen Graphen in Desktop-, Report- oder Papierumgebungen. Obwohl interaktive Plots für Web-Präsentationen mit matplotlib erstellt werden können (mehr in der matplotlib docs]), nutzt die Bibliothek plotly viele interaktivere Web-Plotting-Optionen innerhalb einer einfach zu bedienenden API. plotly kann auch mit JSON-ähnlichen Daten (im Internet gespeichert) umgehen, um Webanwendungen mit Dash zu erstellen. Nur eine Frage: Das Unternehmen hintergrund ist geschäftsorientiert.
Watch this section as a video
Watch this section on plotly as a video on the @Hydro-Morphodynamics channel on YouTube.
Installation¶
plotly ist kein Standardpaket weder in der flusstoolsUmgebungsdatei (environment.yml), noch in der conda base Umgebung. Daher muss es manuell mit conda-Prompt (oder Conda Navigator installiert werden, wenn Sie die Desktop-Version bevorzugen). für die Nutzung mit Jupyter, öffnen Sie conda-Prompt, um plotly für:
jupyter usage and a conda environment:
conda install plotly(confirm installation when asked for it)
jupyter labextension install jupyterlab-plotly@4.11.0(change version4.11.0to latest version listed here)
optional:conda install -c plotly chart-studio(good for other plots than featured on this page)jupyter Nutzung in einer *virtuellen Umgebung:
pip install plotly
Für die Fehlerbehebung, besuchen Sie die Website des Entwicklers und beheben Sie Probleme mit jupyter oder Python(es kann einige sein...).
** Installieren Sie plotly in flussenv (z.B. für die Verwendung mit Jupyter, PyCharm oder VS-Code)* entweder:
a conda Environment (recall installation instructions):
conda activate flussenvconda install plotly(bestätigen Sie die Installation, wenn Sie darum gebeten haben)conda install "notebook>=5.3" "ipywidgets>=7.2"
pip Umwelt (recall installation instructions):
source vflussenv/bin/activatepip install plotly
Lesen Sie mehr über die Installation von Paketen in einem conda environmen oder pip environment.
Verwendung (Einfache Grundstücke)¶
plotly kommt mit Datensätzen, die online für Schaufenster abgefragt werden können. Das folgende Beispiel verwendet einen dieser Datensätze (siehe mehr unter 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')In der Hydraulik bevorzugen wir häufig die Visualisierung von Daten in lokal gespeicherten Textdateien, beispielsweise nach der Ausgabe von 2d-numerischer Modellierung mit NumPy oder Pandas. plotly arbeitet Hand-in-Hand mit pandas und das folgende Beispiel zeigt pandas Datenrahmen, bauen aus einer csv Datei, mit ploty (bessere Lösungen für pandas Datenrahmensortierung sind in der pandas reshaping section dargestellt). Das folgende Beispiel verwendet plotly.offline, um Daten im Notebook-Modus (pyo.init_notebook_mode()) und pyo.iplot() zu erstellen, um Plotfunktionen an ein lokales Skript für interaktives Ploten zu schreiben (download temperatur 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')Interaktive Kartenanwendungen¶
plotly verwendet das GeoJSONDatenformat (ein offener Standard für einfache geospatiale Objekte) in interaktiven Karten. Die Entwickler bieten viele Beispiele in ihrer Dokumentation und der untere Codeblock repliziert eine Karte, die die Arbeitslosenquoten in den Vereinigten Staaten darstellt. Weitere Beispiele finden Sie auf der developer’s website.
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()Viele weitere Karten sind verfügbar - einige von ihnen benötigen ein Mapbox-Konto und die Erstellung eines öffentlichen Tokens (lesen Sie mehr unter plotly.com).
