Python Plotly Express Tutorial: Eindrucksvolle Visualisierungen freischalten

Plotly geht weit über schöne Visualisierungen hinaus: Es hilft dir, das volle Potenzial deiner Daten zu entfalten und Insights sichtbar zu machen, die sonst verborgen blieben. Es schlägt die Brücke zwischen der Sprache der Zahlen und der Sprache guter Stories – und ermöglicht es Einzelnen wie Organisationen, fundierte Entscheidungen zu treffen und echte Veränderungen anzustoßen.

So beschreibt ChatGPT Plotly – und es trifft den Kern: Plotly gehört zu den besten Bibliotheken für Datenvisualisierung.

Damit erstellst du hochinteraktive und visuell ansprechende Diagramme wie dieses hier:

Heute lernst du die Grundlagen, um mit Plotly beeindruckende Visuals zu bauen.

Grundlagen von Plotly Express

Wie in jedem Tutorial starten wir mit der Installation der Bibliothek über pip (oder, wenn du magst, conda).

$ pip install --upgrade plotly
$ conda install -c conda-forge plotly

Plotly wird regelmäßig aktualisiert. Füge deshalb das Tag --upgrade hinzu, wenn du die Bibliothek bereits installiert hast.

Das Tutorial konzentriert sich auf die Express-API von Plotly, die 2019 eingeführt wurde und viele Vorteile gegenüber den älteren Zugängen zur Kernbibliothek bietet:

• Einfache Syntax (liest sich fast wie Englisch)
• Große Bandbreite an Visualisierungen (oder Bausteine für eigene Typen)
• Automatische Achsen- und Farbschwellen
• Integration mit pandas (du kannst das Plotly-Backend für die pandas-.plot-Funktion nutzen)

So ist ein Basisplot in Plotly Express aufgebaut:

import plotly.express as px

fig = px.plotting_function(
    dataframe,
    x='column-for-xaxis',
    y='column-for-yaxis',
    title='Title For the Plot',
    width=width_in_pixels,
    height=height_in_pixels
)

fig.show()

Unterschiedliche Plots haben ihre eigenen Funktionsnamen, z. B. histogram oder scatter im Modul express, das wir als px laden. Das erste Argument jeder Plot-Funktion ist das DataFrame, dazu gibst du die Spaltennamen für die X- und Y-Achse an.

Als Best Practice solltest du deinen Plots immer einen aussagekräftigen title geben, damit Leserinnen und Leser sofort wissen, worum es geht.

Nach dem Aufruf einer Plot-Funktion erhältst du ein Figure-Objekt. Darauf rufst du die Methode show auf, um den Plot in deinem Notebook anzuzeigen.

Zum Starten brauchen wir einen Datensatz. Für dieses Tutorial verwenden wir das Diamonds-Dataset. Es enthält eine gute Mischung aus numerischen und kategorialen Merkmalen – ideal für unsere Zwecke.

import pandas as pd

diamonds = pd.read_csv("data/diamonds.csv")

diamonds.head()

Der Datensatz umfasst über 53.000 Diamanten mit 10 physikalischen Eigenschaften. Die Basisstatistiken siehst du unten.

diamonds.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 53940 entries, 0 to 53939
Data columns (total 10 columns):
#   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
0   carat    53940 non-null  float64
1   cut      53940 non-null  object
2   color    53940 non-null  object
3   clarity  53940 non-null  object
4   depth    53940 non-null  float64
5   table    53940 non-null  float64
6   price    53940 non-null  int64 
7   x        53940 non-null  float64
8   y        53940 non-null  float64
9   z        53940 non-null  float64
dtypes: float64(6), int64(1), object(3)
memory usage: 4.1+ MB

diamonds.describe()

Einer der ersten Schritte der Explorativen Datenanalyse (EDA) ist das Untersuchen einzelner Verteilungen.

Plotly bietet dafür viele Diagrammtypen: Histogramme, Boxplots, Violinplots, Balkendiagramme usw. Schauen wir uns ein paar davon an.

Histogramme in Plotly Express

Ein Histogramm gehört meist zu den ersten Visuals, die man lernt.

Es ordnet die Werte einer Verteilung in Bins ein und zeigt dann mit Balken, wie viele Werte in jedes Bin fallen:

import plotly.express as px
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  width=600,
  height=400,
)
​
fig.show()

Fährst du mit der Maus über einen Balken, siehst du den Wertebereich des zugehörigen Bins. Plotly wählt die Anzahl der Bins automatisch. Wenn du sie selbst festlegen willst, nutze den Parameter nbins.

Die perfekte Bin-Anzahl für jede Verteilung zu finden, ist jedoch schwierig. Bewährt hat sich die Faustregel, die Anzahl der Bins auf die Quadratwurzel der Länge der Verteilung zu setzen:

# Die passende Anzahl an Bins bestimmen
nbins = int(len(diamonds) ** (1 / 2))
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  nbins=nbins,
  width=600,
  height=400,
)
​
fig.show()

Balkendiagramme in Plotly Express

Histogramme analysieren quantitative Merkmale. Für kategoriale Daten verwenden wir Balkendiagramme. Wenn wir zum Beispiel die kategoriale Spalte cut an histogram übergeben, erhalten wir eine Art Balkendiagramm namens Countplot. Genau: Er zählt die Beobachtungen pro Kategorie.

fig = px.histogram(diamonds, x="cut")
​
fig.show()

Moment, uns fehlen noch Beschriftungen! Das beheben wir mit update_layout. Damit kannst du viele Aspekte einer Figure nachträglich anpassen.

fig.update_layout(
  title="The number of diamonds in each diamond cut category",
  xaxis_title="",
  yaxis_title="Count",
)

title kennst du schon. xaxis_title und yaxis_title ersetzen die von Plotly automatisch erzeugten Achsentitel (standardmäßig die Spaltennamen).

Als Nächstes sehen wir uns den durchschnittlichen Preis je Diamant-Schliffkategorie an. Zuerst nutzen wir pandas groupby:

mean_prices = (
    diamonds.groupby("cut")["price"].mean().reset_index()
)

mean_prices

Durch das Anhängen von reset_index an die groupby-Operation wird die Ausgabe wieder zu einem DataFrame – und Plotly liebt DataFrames. Also übergeben wir es an die Funktion bar:

fig = px.bar(mean_prices, x="cut", y="price")
​
fig.update_layout(
  title="Average diamond prices for each cut category",
  xaxis_title="",
  yaxis_title="Mean price ($)",
)
​
fig.show()

bar erwartet eine kategoriale und eine numerische Variable und erzeugt für jede Zeile im übergebenen DataFrame einen Balken. Das Ergebnis ist ein angenehm lesbarer Preisvergleich je Diamanttyp.

Boxplots in Plotly Express

Ein weiterer Klassiker zur Analyse von Verteilungen ist der Boxplot, in Plotly Express mit box erstellt:

fig = px.box(diamonds, x="clarity", y="carat")
​
fig.update_layout(
  title="Distribution of diamond carats for each clarity category",
  xaxis_title="Clarity",
  yaxis_title="Carat",
)
​
fig.show()

Statt nur Durchschnittswerte zu zeigen, visualisiert der Boxplot mehrere Kennzahlen:

Du siehst:

• Minimum/Maximum
• Median
• 25. Perzentil
• 75. Perzentil
• sowie Ausreißer

für jede Reinheitskategorie.

Violinplots in Plotly Express

Ein weiterer spannender Diagrammtyp für Verteilungen ist der Violinplot. Er ist im Grunde ein Boxplot mit zusätzlicher Dichtedarstellung:

fig = px.violin(diamonds, x="cut", y="price")
​
fig.show()

Statt einer Box zeigt er eine glatte Kurve, die die Dichte eines Merkmals angibt. Um zusätzlich einen Boxplot zu überlagern, setze den Parameter box auf True:

fig = px.violin(diamonds, x="cut", y="price", box=True)
​
fig.show()

Im Unterschied zum Boxplot, der nur Zusammenfassungsstatistiken zeigt, macht der Violinplot auch die Form der Verteilung sichtbar.

Beziehungen zwischen Merkmalen mit Plotly Express visualisieren

Wenn du eng verwandte Merkmale gemeinsam darstellst, werden neue Muster und Insights sichtbar. Nehmen wir an, das Karatgewicht eines Diamanten ist der Haupttreiber für den Preis – dann lohnt sich ein Blick auf diese Beziehung.

Streudiagramme in Plotly Express

Mit einem Streudiagramm (px.scatter) zeichnen wir alle Diamanten als Punkte. Die Position ergibt sich aus ihren jeweiligen Preis- und Karatwerten:

fig = px.scatter(diamonds, x="price", y="carat")
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

Hier haben wir ein typisches Problem der Überlagerung (Overplotting): Es sind zu viele Daten in einem Plot, sodass echte Muster verdeckt werden.

Abhilfe schafft es, nur etwa 10% des Datensatzes zu plotten – das reicht meist, um Muster zu erkennen:

fig = px.scatter(
  diamonds.sample(5000), x="price", y="carat"
)
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

In scatter übergeben wir hier nur 5000 Zeilen (.sample(5000)). So wird ein leichter Aufwärtstrend in der Beziehung zwischen Preis und Karat sichtbar.

Heatmaps in Plotly Express

Heatmaps eignen sich hervorragend für komplexe Datensätze, etwa große Matrizen, in denen Zahlenkolonnen Muster schwer erkennen lassen.

Eine Heatmap weist Zellen Farben entsprechend ihrer Ausprägung zu. Ein typischer Anwendungsfall ist die Korrelationsmatrix eines Datensatzes.

Korrelation misst die lineare Beziehung zwischen numerischen Merkmalen. Jede Zelle der Matrix steht für die Korrelation eines Merkmals-Paares.

Die Korrelationsmatrix berechnest du mit der pandas-Methode corr, die ein DataFrame zurückgibt. Übergibst du dieses an die imshow-Funktion von Express, erhältst du eine Heatmap:

import plotly.express as px
​
# Create heatmap using Plotly Express
fig = px.imshow(
  diamonds.corr(),
  color_continuous_scale="Inferno_r",
)
​
# Show plot
fig.show()

Die Korrelation liegt zwischen -1 und 1. Werte nahe an den Rändern stehen für eine starke positive bzw. negative lineare Beziehung zwischen Merkmalen.

Wir wählen hier die umgekehrte Inferno-Farbskala über den Parameter color_continuous_scale. Weitere Skalen findest du in der Übersicht der Plotly-Dokumentation.

Plots in Plotly Express anpassen

Einer der größten Pluspunkte der Plotly-Express-API ist die einfache Anpassbarkeit der Plots.

Die Funktion update_layout bietet viele Parameter, mit denen du nahezu jeden Aspekt deiner Diagramme verändern kannst.

Abhängig davon, wo deine Plots gezeigt werden, ist es deine Aufgabe, sie für jedes Publikum, jeden Ort und jedes Medium passend aufzubereiten.

Als Erstes wählst du oft ein Plot-Theme. Themes in Plotly sind Standardkonfigurationen, die fast alle Komponenten steuern.

Du änderst es über den Parameter template in jeder Plot-Funktion:

sample = diamonds.sample(3000)
​
fig = px.scatter(
  sample, x="price", y="carat", template="ggplot2"
)
​
fig.show()

Beliebt sind etwa ggplot2, seaborn, plotly_dark und presentation. Die vollständige Liste siehst du mit plotly.io.templates.

Farben

Bisher waren unsere Streudiagramme zweidimensional. Über Farben kannst du zusätzliche Informationen einbringen.

Zum Beispiel können wir jeden Punkt nach der Kategorie des Diamanten einfärben. Übergib dafür einfach cut an den Parameter color:

sample = diamonds.sample(3000)
​
fig = px.scatter(sample, x="price", y="carat", color="cut")
​
fig.show()

Der Parameter color sorgt zugleich für eine Legende, die die Kategorienfarben zeigt.

Markergröße

Eine weitere Möglichkeit ist, ein numerisches Merkmal über die Punktgröße zu visualisieren.

Setzen wir size auf carat, erhalten wir unterschiedlich große Punkte je nach Karat:

fig = px.scatter(sample, x="price", y="x", size="carat")
​
fig.show()

Wie wäre es mit Farbe und Größe zugleich? Klar, geht:

fig = px.scatter(
  sample, x="price", y="x", size="carat", color="cut"
)
​
fig.show()

Dieser Plot ist jedoch nicht besonders aussagekräftig – er enthält zu viele Informationen, um sie auf einen Blick zu erfassen. Gute Praxis: Packe nicht mehr als drei Merkmale in einen einzelnen Plot.

Fazit

Glückwunsch, du bist bis zum Ende gekommen! Du hast genug gelernt, um Plotly mit diesen Ressourcen eigenständig weiter zu vertiefen:

• Introduction to data visualization with Plotly in Python course
• Data Visualization with Plotly in R tutorial
• Creating histograms in Plotly tutorial

Außerdem lohnt sich ein Blick auf die Graph Objects API von Plotly – für noch mehr Anpassungen, volle Kontrolle über Interaktivität und Animationen sowie Unterstützung für fortgeschrittene Visualisierungstypen.