Hej Leute,

in diesem Artikel geht es darum, wie ihr Diagramme und Charts in Python erstellt. Dafür gibt es verschiedene Packages wie Matplotlib, Seaborn, Altair usw, wobei Matplotlib sowas wie der Standard ist. Ein Scatterplot (Punktwolke) oder ein Barplot (Säulendiagramm) mit Matplotlib zu erstellen ist eigentlich ganz einfach. Der Teufel steckt aber im Detail, wenn man Anpassungen wie z.B. Farben, Achsenbeschriftungen vornehmen möchte.

Dieser Artikel gibt Euch einen ersten Einstieg in Python-Charts mit Matplotlib. Aber fangen wir bei den Datenvisualisierungs-Packages an:

 

Welche Daten-Visualisierungs-Bibliothek ist die beste?

Zuerst einmal haben wir die Qual der Wahl, denn Libraries zum Erzeugen von Charts und Diagrammen in Python gibt es einige. Die Frage nach der besten ist so natürlich nicht wirklich zu beantworten, denn alle haben ihre Stärken und Schwächen.

Wichtig ist am Anfang, dass ihr euch auf eine Visualisierungs-Bibliothek festlegt. Später könnt ihr dann weitere in euer Repertoire aufnehmen.

  • Matplotlib ist der Quasi-Standard, also die am weitesten verbreitete Bibliothek und kein Data Scientist, der in Python programmiert, kommt daran vorbei. Matplotlib kann fast alles. Das ist aber auch das Problem, denn dadurch ist das Interface recht komplex und man braucht mehr Zeilen Code, bis man ein schönes Diagramm gezaubert hat.
  • Seaborn basiert auf Matplotlib, d.h. es ruft im Hintergrund Matplotlib auf. Das Interface macht es leichter, insbesondere hat Seaborn deutlich schönere Standard-Einstellungen. Damit lassen sich viele Charts mit deutlich weniger Code erstellen. Auf der anderen Seite ist es nicht so flexibel wie Matplotlib und muss dann eben doch darauf zurückgreifen.
  • Plotly bietet neben vielen Charttypen einiges an Interaktivität wie Reinzoomen oder Mouse-Over-Tooltips out of the box. Plotly gibt es für mehrere Programmiersprachen, also für R, Julia und Javascript.
  • Bokeh unterstützt wie Plotly ebenfalls interaktive Diagramme und ist zum Beispiel auch für R verfügbar.
  • Altair bietet ein tolles Abstraktionslevel. Durch eine durchdachte „Grammar of Graphics“ macht es uns die Charterstellung und die Transformation von Daten einfacher. Zudem lassen sich auch mehrere Charts verlinken und interaktiv machen.
  • ggplot ist in der R-Community der geniale Platzhirsch, an dem kein Weg vorbeiführt. Die gute Nachricht für R-Umsteiger ist, dass es eine Adaption für Python gibt.
  • Holoviz ist ein ganzes Paket aus verschiedenen Visualisierungstools, also eine Ebene höher. Man kann neben dem mitgelieferten Holoview auch Bokeh, Plotly oder Matplotlib für die zugrundeliegende Visualisierung verwenden.

Ok, das sind ja viel zu viele Optionen, um die Anwendung zu verstehen und die Vor- und Nachteile gegeneinander abzuwägen.

Mein Rat: Fange mit Matplotlib an.

Diese Grafikbibliothek kann zum einen unglaublich viel. Zum anderen ist sie sehr weit verbreitet, dass man früher oder später im Data Science Umfeld auf Code stößt, der Matplotlib verwendet.

 

Installation von Matplotlib

Falls Du die Python-Distributionen Anaconda oder Miniconda verwendest, gehst Du einfach in das gewünschte Environment. Wenn Du conda-Anfänger bist, dann findest Du in meinem Artikel zur Installation von Anaconda eine Anleitung. Die aktuelle Version von matplotlib ist auf dem conda-forge Kanal zu finden, diesen kannst Du mittels folgenden Befehls als Standardkanal hinzufügen, falls Du das nicht sowieso schon gemacht hast.

conda config --add channels conda-forge

Dann installierst Du matplotlib einfach mit

conda install matplotlib

Falls Du pip als Paketmanager benutzt, dann geht die Installation über

pip install matplotlib

bzw.

python -m pip install matplotlib

 

 

Punktwolke / Scatterplot mit matplotlib

Ein Scatterplot ist immer dann sinnvoll, wenn man den Zusammenhang zwischen zwei (metrischen) Variablen darstellen möchte. Die Wertepaare (x,y) werden einfach als Punkte eingezeichnet.

Ein einfaches Beispiel für eine Punktwolke mit Matplotlib erstellt
Der Code dazu ist ganz einfach:
# Import der Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
 
# Daten erzeugen= 100= np.random.normal(0,1,n)= np.random.normal(0,1,n)
 
# Scatterplot
plt.scatter(x, y)
plt.title('Scatter Plot')
plt.xlabel('x')
plt.ylabel('y')
 
plt.show()

Zuerst werden die Bibliotheken matplotlib.pyplot und numpy mit den üblichen Abkürzungen importiert. Numpy brauchen wir für die Erzeugung der Zufallswerte, denn im zweiten Schritt generieren wir 100 standard-normalverteilte Werte für x und für y.

Dann kommt die eigentliche Plot-Erstellung mittels plt.scatter. Wir versehen den Plot noch mit Titel, x-Achsen- und y-Achsen-Beschriftung. Dann wird er mit plt.show dargestellt.

In einem Jupyter Notebook (Endung .ipynb) wird die Grafik direkt im Notebook angezeigt, egal ob ihr Jupyter Lab oder VS Code benutzt. Als normales Python-Script (Endung .py) hängt es ein bisschen vom Editor ab. VS Code oder PyCharm öffnen unter Windows ein separates Fenster. Das ist das gleiche Verhalten wie direkt von der Konsole aus. Spyder hat einen Tab „Abbildungen“, wo die Grafik angezeigt wird. Spyder gibt aber auch den Hinweis, dass man das auf die Konsole umstellen kann.

Warum habe ich oben eigentlich geschrieben, dass ein Scatterplot nur für metrische Variablen sinnvoll ist? Na ja, hat eine oder beide Variablen nur wenige Werte (also z.B. nur 0 und 1) oder ist kategoriell, dann kann man zwar so einen Scatterplot zeichnen, sieht aber nicht viel, weil es auf der einen Achse bzw. auf beiden Achsen nur wenige Werte gibt. Daher liegen viele Punkte übereinander.

# Daten erzeugen
n = 100
x = np.random.binomial(1, 0.2, n)
y = np.random.binomial(3, 0.5, n)
 
# Scatterplot
plt.scatter(x, y)
plt.title("Scatter Plot")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
Scatterplots/Punktwolken funktionieren bei kategoriellen bzw. ordinalen Daten nicht gut, da viele Punkte übereinander liegen

Im Package seaborn gibt es Abhilfe, denn dort gibt es die Funktionen stripplot und swarmplot:

Stripplot mit seaborn

Ein Codebeispiel für einen Stripplot mit dem Python-Package seaborn, um Variablen mit wenigen Werten darzustellen

Swarmplot mit seaborn

Ein Swarmplot (Beeplot) mit dem Python-Package seaborn als Alternative zum Scatterplot bei wenigen Kategorien
Und hier der Code für die Stripplot und Swarmplot mittels des Python-Packages seaborn:
import seaborn as sns
import pandas as pd
 
# Daten erzeugen
n = 100
x = np.random.binomial(1, 0.2, n)
y = np.random.binomial(3, 0.5, n)
df = pd.DataFrame({'x':x, 'y':y})
 
sns.swarmplot(x='x',y='y',data=df)
# despine entfernt den oberen und rechten Rand, es bleiben die Achsen
sns.despine()
 
sns.stripplot(x='x', y='y', data=df, size=16, alpha=.2, jitter=True, edgecolor='none')
sns.despine()

Barcharts/Säulendiagramme in Matplotlib bzw. Seaborn erstellen

Säulen- oder Balkendiagramme gehören zu den beliebtesten Charttypen, sind sie doch meist schnell erstellt und intuitiv zu verstehen.

In einem Säulendiagramm werden auf der x-Achse Kategorien abgetragen. Zu jeder Kategorie gibt es eine Säule, deren Höhe durch den darzustellenden Wert auf der y-Achse bestimmt ist. Nehmen wir zum Beispiel ein Säulendiagramm zu Haustieren in Deutschland. Dabei gibt es 4 Säulen für Katzen, Hunde, Kleintiere und Ziervögel. Die Höhe der Säulen entspricht der Anzahl der jeweiligen Art in Deutschland.

Python-Code-Beispiel für ein Barchart (Säulendiagramm) mit matplotlib
In Matplotlib ist das ganz einfach mit der Funktion plt.bar realisiert. Wir ergänzen noch die Beschriftung der Achsen sowie den Titel. Schließlich entfernen wir die Markierungsstriche auf der x-Achse.
tiere = ('Katzen', 'Hunde', 'Kleintiere', 'Ziervögel')
anzahl = [15.7, 10.7, 5, 3.5]
 
y_pos = np.arange(len(tiere))
 
plt.bar(y_pos, anzahl, align='center')
plt.xticks(y_pos, tiere)
plt.ylabel('Anzahl in Millionen')
plt.title('Haustiere in Deutschland (2020)')
# Striche auf x-Achse ausschalten
plt.tick_params(
    axis='x',
    which='both', #major und minor ticks
    bottom=False  # ticks auf der x-Achse (unten)
)
plt.show()

Statt eines umschließenden Rands, also einem Diagramm in einer Box, wollen wir nur die x- und y-Achse haben. Wir müssen dazu den rechten und oberen Rand entfernen. Das geht in Matplotlib mit dem Attribut spines, allerdings ist das ein Attribut der Achsen. Diese müssen wir uns also mit der Funktion gca() erst holen.

ax = plt.gca()
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)

Mit dem Package seaborn geht es einfacher, denn dort gibt es die Funktion despine, die genau die rechte und obere Achse entfernt.

# Barplot in Seaborn
df = pd.DataFrame({'Tiere':tiere, 'Anzahl':anzahl})
 
sns.set_theme(style="ticks", palette=None)
g = sns.barplot(x='Tiere', y='Anzahl', data=df, color='#69d')
g.set(xlabel = None, ylabel='Anzahl in Millionen', title='Haustiere in Deutschland (2020)')
g.tick_params(bottom=False)
sns.despine()
Ein Säulendiagramm (barplot) mit seaborn in Python erstellt

Balkendiagramm in Matplotlib

Ein Balkendiagramm ist übrigens einfach nur ein Säulendiagramm mit vertauschten Achsen. Dann befinden sich die Kategorien auf der y-Achse und die Länge der Balken entspricht dem Wert auf der x-Achse. Balkendiagramme eignen sich besonders, wenn man lange Kategorienamen hat oder wenn man viele Kategorien hat.

In Matplotlib gibt es für Balkendiagramme die Funktion barh(). Natürlich müssen wir jetzt die Anpassungen der Achsen vertauschen.

# Balkendiagramm in matplotlib
plt.barh(y_pos, anzahl, align='center')
plt.yticks(y_pos, tiere)
plt.xlabel('Anzahl in Millionen')
plt.title('Haustiere in Deutschland (2020)')
plt.tick_params(
    axis='y',
    which='both', #major und minor ticks
    left=False  # ticks auf der y-Achse (links)
)
ax = plt.gca()
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
 
plt.show()
Ein Balkendiagramm als gedrehtes Säulendiagramm. In Python Matplotlib mittels der Funktion barh

Matplotlib Colors – Bringt Farbe in Eure Python Charts

Der aufmerksame Leser (Du bist bestimmt einer 😉) hat schon entdeckt, dass ich im Seaborn-Barplot Codebeispiel die Füllfarbe der Säulen mittels color gesetzt habe. Das geht auch in den normalen Matplotlib-Diagrammen, also als Parameter in der Funktion plt.bar() bzw. plt.barh().

Dabei hat man mehrere Möglichkeiten, die Farbe anzugeben:

  • Als Tupel mit RGB-Werten zwischen 0 und 1, also zuerst der Wert für Rot, dann für Grün und schließlich für Blau: (0.4, 0.2, 0.1)
  • Als Tupel mit RGBA-Werten zwischen 0 und 1. Hier kommt zu den RGB-Werten noch ein vierter Wert, nämlich der alpha-Wert für die Sichtbarkeit/Transparenz. Dabei bedeutet 1 undurchsichtig und 0 vollständig transparent, bei 0 sieht man also die Farbe gar nicht mehr.
  • Man kann auch einen String mit den RGB-Werten in Hexadezimal-Schreibweise benutzen. Dabei hat man für jede der drei Grundfarben Werte zwischen 0 und 255, damit diese aber in zwei Zeichen passen, benutzt man das 16er-System mit den Ziffern 0-9, A, B, C, D, E, F. Die Zahl 11 entspricht also B, die Zahl 44 entspricht 2C (= 2*16 + 12) und 255 ist FF. Aber keine Sorge, fast jedes Grafikprogramm oder Browser-Plugins geben Euch den Code für eine Farbe aus. Der sieht dann so aus: „#33AF43“
  • Wollen wir wieder Transparenzen hinzufügen, dann ergänzen wir zwei Hexadezimal-Ziffern am Ende für den Alpha-Wert.
  • Es sind auch eine ganze Reihe von Farben definiert, die man einfach per Namen benutzen kann, z.B. „aquamarine“, „mediumseegreen“ usw. Diese entsprechen dem X11/CSS4-Standard (ohne Leerzeichen) und man findet eine Liste z.B. auf Wikipedia in dem X11 color names Artikel
plt.bar(y_pos, anzahl, align='center', color='#AA007F')
plt.xticks(y_pos, tiere)
plt.ylabel('Anzahl in Millionen')
plt.title('Haustiere in Deutschland (2020)')
plt.tick_params(
    axis='x',
    which='both', #major und minor ticks
    bottom=False  # ticks auf der x-Achse (unten)
)
ax = plt.gca()
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
 
plt.show()
Die Farbe in matplotlib lässt sich über den Parameter color in der Barplot-Funktion einstellen

Fazit

Kenntnisse in matplotlib sind ein Muss für jeden Data Scientisten, der in Python programmiert. Auch wenn andere Packages zum Teil eleganter und systematischer sind, so ist die Popularität von Matplotlib ungebrochen. D.h. in der Praxis begegnet einem irgendwann auf jeden Fall Matplotlib-Code, den man verstehen bzw. anpassen muss.

Matplotlib ist eine umfangreiche Bibliothek. Wir haben hier natürlich nur an der Oberfläche gekratzt. Aber so habt ihr schon mal einen ersten Eindruck, wie die Erstellung von Charts in Matplotlib funktioniert.

Happy Data Visualisierung,

Euer Holger