Visualisierung mit Matplotlib

Matplotlib ist eine mächtige Python-Bibliothek, die viele Funktionen zur graphischen Darstellung von Daten in Form von Plots und Diagrammen bereitstellt. In diesem Kapitel lernen wir die grundlegende Funktionsweise kennen.

Erste Schritte¶

Ähnlich wie bei NumPy müssen wir Matplotlib zunächst installieren. Dies geschieht in einer Conda-Umgebung mit folgendem Befehl:

conda install -c conda-forge matplotlib

Anschließend können wir Matplotlib – genauer gesagt das Submodul matplotlib.pyplot – in unser Programm einbinden:

Der wichtigste Befehl ist plt.plot(...). Wir können plt.plot? eingeben, um uns die Dokumentation anzeigen zu lassen.

In der einfachsten Form erwartet diese Funktion zwei Vektoren mit den $x$- bzw. $y$-Koordinaten einer Punktwolke. Diese Vektoren können Listen oder NumPy-Arrays sein.

Die Sinusfunktion können wir beispielsweise wie folgt plotten:

Hier sehen wir auch eine schöne Anwendung der elementweise definierten mathematischen Funktionen aus numpy.

Gestaltung von Plots¶

Machen wir unseren Plot noch etwas schöner:

Im Prinzip hat Matplotlib unsere Punktwolke mit Koordinaten aus x und y gezeichnet und die Punkte mit Linien verbunden. Es gibt jedoch viele Möglichkeiten, das Aussehen der Linien und Marker anzupassen.

Die Zeichenkette ‘ro-’ gibt Farbe (r), Marker (o) und Linienstil (-) an.

Im Hilfetext plt.plot? sind noch weitere Linien- und Markertypen erklärt. Vordefinierte Farben im Submodul matplotlib.colors. Es gibt verschiedene Farbpaletten. Die Grundfarben sind:

Darüber hinaus gibt es die Farbpalette Tableau, welche häufig für Diagramme verwendet wird:

Außerdem stehen noch viele CSS-Farben zur Verfügung:

Durch Setzen des Parameters color im Plot-Befehl kann eine Farbe aus einer dieser Farbpaletten gewählt werden:

Die Farben können entweder über Kurzbezeichnungen ('r', 'g', 'b'), über Tableau-Namen ('tab:blue', 'tab:orange', ...) oder über CSS-Farbnamen ('firebrick', 'gold', 'navy', ...) angegeben werden.

Folgende Tabelle enthält eine vollständige Auflistung aller vordefinierter Farben:

Bei der Fehleranalyse sind oft logarithmische Achsen von Interesse.
Angenommen, wir analysieren einen iterativen Algorithmus und messen die Entfernung $\text{err}_n$ zwischen der exakten Lösung und der berechneten Näherungslösung nach $n$ Iterationen.

Man sagt, das Verfahren konvergiert

• Q-linear, falls
  

  $$\text{err}_n \le C\,\text{err}_{n-1}, \qquad C\in(0,1)$$

  (1)

• Q-superlinear, falls
  

  $$\text{err}_n \le \varepsilon_n\,\text{err}_{n-1}$$

  (2)

  mit einer Nullfolge $\varepsilon_n \searrow 0$

• Q-quadratisch, falls
  

  $$\text{err}_n \le C\,\text{err}_{n-1}^2, \qquad C>0$$

  (3)

Stellen wir den Fehlerverlauf einmal in einem gewöhnlichen kartesischen Koordinatensystem und einmal in einem Koordinatensystem mit logarithmischer $y$-Achse dar:

Wir sehen, dass eine Q-linear konvergente Folge im Plot mit logarithmischer $y$-Achse als lineare Funktion erscheint.

Analog dazu kann auch die $x$-Achse mit plt.semilogx() logarithmisch skaliert werden.
Für die oben betrachtete Anwendung ist dies allerdings wenig sinnvoll.

Balken-, Stab- und Tortendiagramme¶

Schauen wir uns weitere elementare Plot-Typen an. Angenommen wir haben die Auswertung einer Umfrage vorliegen, und möchten diese graphisch aufbereiten. Unsere Beispieldaten sind:

Anstelle des Befehls plt.plot können auch andere Plot-Typen verwendet werden:

• stem – Stabdiagramm

• scatter – Streudiagramm

• bar – Balkendiagramm

• pie – Tortendiagramm

Im folgenden Beispiel werden diese Darstellungsformen miteinander verglichen:

Plots für Skalar- und Vektorfelder¶

Auch für die graphische Darstellung von Skalarfeldern $f\colon \mathbb{R}^2 \to \mathbb{R}$ und Vektorfeldern $\vec F\colon \mathbb{R}^2 \to \mathbb{R}^2$ stellt Matplotlib verschiedene Funktionen bereit.

Viele Darstellungen von Skalarfeldern erwarten als Argument drei Matrizen: eine für die $x$-Koordinaten, eine für die $y$-Koordinaten und eine für den Funktionswert $f(x,y)$.

Hilfreich ist hier die Funktion numpy.meshgrid, mit der wir aus zwei eindimensionalen Gittern ein zweidimensionales Tensorprodukt-Gitter erzeugen.

Countour-Plots:

Eine mögliche Darstellung eines solchen Skalarfeldes ist ein Contour-Plot. Dabei werden die Kurven

für verschiedene Werte $c_1<c_2<\dots<c_{\text{levels}}$ eingezeichnet:

Colormap-Plots:

Eine weitere Möglichkeit ist ein Color-Plot, bei dem der Funktionswert an einer Stelle $(x,y)$ über eine Farbskala dargestellt wird:

3D-Darstellungen von Skalarfeldern:

Skalarfelder lassen sich auch in einem dreidimensionalen Koordinatensystem darstellen. Dabei werden die Argumente auf der $x$- und $y$-Achse dargestellt und der Funktionswert auf der $z$-Achse. Hier müssen wir uns zunächst ein dreidimensionales Koordinatensystem erzeugen. Dazu erzeugen wir eine neue Abbildung via

fig = plt.figure()

und fügen ein 3D-Koordinatensystem hinzu

ax = fig.add_subplot(projection='3d')

ax stellt dann die entsprechenden Plot-Befehle bereit. Hier ein Beispiel:

Plots für Vektorfelder:

Vektorfelder $\vec F:\mathbb{R}^2\to\mathbb{R}^2$ können in Matplotlib mit sogenannten Quiver-Plots visualisiert werden. In einem Quiver-Plot wird der Funktionswert $\vec F(\vec x)$ durch einen Pfeil beginnend im Punkt $\vec x$ gekennzeichnet.

Beispiel: Das Vektorfeld

lassen wir auf einem regelmäßigen Punktgitter darstellen. Optional können die Pfeile nach ihrer Länge eingefärbt werden.

Plots für Kurven¶

Auch Kurven lassen sich in Matplotlib zeichnen. Eine Kurve ist zunächst eine Menge an Punkten

mit einer sogenannten Kurvenparametrisierung $\vec x\colon[t_a,t_b]\to\mathbb{R}^n$, welche als regulär vorrausgesetzt wird, d.h., $\dot{\vec x}(t)\ne 0$ für alle $t\in [t_a,t_b]$.

Kurven in der Ebene:

Für eine ebene Kurve ($n=2$) können wir den normalen Plot-Befehl nutzen. Das Kleeblatt

zeichnen wir beispielsweise mit

Kurven im Raum:

Ähnlich kann man Raumkurven ($n=3$) zeichnen, man benötigt nur vorher ein dreidimensionales Koordinatensystem. Wie wir das anlegen haben wir aber schon gesehen. Wir zeichnen hier die Schraubenlinie