Matplotlib

Was ist Matplotlib?

Viele Probleme lassen sich besser verstehen oder lösen, wenn man sie grafisch darstellt. Beispielsweise kann man bei einer linearen Regression gut sehen, ob die bestimmte Regressionsgrade wirklich mittig zwischen den Punkten verläuft, wenn man sie zeichnet. Genauso kann man die Verteilung von Werten grafisch sehr schnell überblicken.

Da die grafische Darstellung von Werten und Funktionen so wichtig ist, bietet Python mit Matplotlib eine Bibliothek an, mit der man sehr einfach und schnell Funktionen und Werte zeichnen kann.

Bibliothek zum Plotten von Graphen
Harmoniert gut mit NumPy
Syntax ähnlich zu Matlab

Matplotlib passt sehr gut zu NumPy, weil es direkt mit den NumPy-Arrays umgehen kann und deren Inhalt zeichnen. Bei der Syntax der Befehle lehnt sich Matplotlib an die entsprechenden Kommandos von Matlab an.

Beispiel

Als Einstig in das Thema Matplotlib, soll eine Funktion gezeichnet werden. Hier einfach die Funktion $ f(x) = x^2 $.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 1001) #  Zwischen 0 und 10 1001 Werte erzeugen
y = np.power(x, 2) # Y-Werte berechnen
plt.plot(x, y)
plt.show()

Im Beispiel erzeugt der Befehl np.linspace(0, 10, 1001) ein Array mit 1001 Werten im Intervall 0 bis 10. Der Bereich wird also in Schritten a 0.01 durchlaufen. Dieses Array speichern wir in der Variable x.

Im nächsten Schritt wird ein zweites Array y berechnet, dass die Quadrate der Werte aus x enthält. Hier machen wir uns zu Nutze, dass NumPy die Operationen elementweise durchführt, wie also einfach jedes Element aus x quadriert in dem Array y wiederfinden.

Mit plt.plot weisen wir Matplotlib an, die beiden Array gegeneinander aufzutragen, wobei als erster Parameter die horizontale x-Achse und als zweiter Parameter die vertikale y-Achse angegeben wird.

Wir könnten jetzt noch weitere Graphen in das Diagramm zeichnen, indem wir weitere plot-Befehle absetzen. Hier soll aber die eine Kurve reichen.

Angezeigt wird der Plot durch den Befehl show(). Nach diesem geht ein neues Fenster auf, indem man die Kurve betrachten kann. Anstelle von show könnte man das Ergebnis auch mit savefig() auf der Festplatte speichern.

Schönere Graphen mit Seaborn

Manchen erscheinen die Grafiken, die aus Matplotlib herausfallen als zu langweilig. In diesem Fall kann man mit dem Modul Seaborn stärkeren Einfluss auf die Ergebnisse und deren Aussehen nehmen.

Mit dem Modul Seaborn kann man die Graphen verschönern

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style("darkgrid") # Style auswählen
plt.tight_layout() # weniger Rand

x = np.linspace(0, 10, 1001) #  Zwischen 0 und 10 1001 Werte erzeugen
y = np.power(x, 2) # Y-Werte berechnen

plt.plot(x, y)
plt.show()

Im Beispiel ist nur das Laden von Seaborn, das Auswählen eines Styles mit set_style und die Verkleinerung der Ränder mit tight_layout() hinzu gekommen.

Das Ergebnis sieht deutlich ansprechender aus, als ohne Seaborn.

Plot als Grafik speichern

Den Plot anzuzeigen ist häufig der erste Schritt zur Analyse der Daten. Später möchte man die Grafik aber vielleicht in einer Hausarbeit verwenden oder weitergeben. Hierzu muss man nur das show durch das Kommando savefig ersetzen.

Der Plot kann als Grafik über pyplot.savefig(name) gespeichert werden

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style("darkgrid") # Style auswählen

x = np.linspace(0, 10, 1000) #  Zwischen 0 und 10 1000 Werte erzeugen
y = np.power(x, 2) # Y-Werte berechnen

plt.plot(x, y)

plt.savefig('square.pdf')

Die Art der Bilddatei bestimmt Matplotlib automatisch aus der Endung des angegebenen Dateinamens. Würde man im Beispiel oben plt.savefig('square.png') angeben, so würde der Plot als PNG-Bild abgelegt.

Achsenbeschriftung

Beschriftung der Achsen

ax.set_xlabel(str): X-Achse beschriften
ax.set_ylabel(str): Y-Achse beschriften
ax.set_title(str): Titel des Diagramms

Wenn man die Achsen beschriften will, muss man sich von Matplotlib das Objekt holen, auf dem die Zeichenoperationen erfolgen. Dies geschieht über den Befehl plt.subplots. Dieser erlaubt es, mehrere Plots in einer Grafik zusammenzufassen und gibt dem Programmierer Zugriff auf die Objekte für die Achsen. Uns interessiert hier nur der zweite Teil, sodass wir die Funktion ohne Parameter aufrufen. Sie gibt zwei Werte zurück:

das Objekt für die Figure (benötigen wir hier nicht) und
das Objekt für die Achsen.

sns.set_style("darkgrid") # Style auswählen

figure, axis = plt.subplots()

x = np.linspace(0, 10, 1000)
y = np.power(x, 2)

axis.set_xlim((1, 5)) # X-Bereich
axis.set_ylim((0, 30)) # Y-Bereich

# Beschriftung der Achsen und Titel
axis.set_xlabel('X-Beschriftung')
axis.set_ylabel('Y-Beschriftung')
axis.set_title('Titel')
plt.tight_layout()

axis.plot(x, y)
plt.show()

Die Imports wurden ausgelassen

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

Das Beispiel setzt die Wertebereiche für die Achsen mit set_xlim und set_ylim und fügt den Achsen mit set_xlabel bzw. set_ylabel Beschriftungen hinzu. Die gesamte Grafik bekommt noch einen Titel über die Methode set_title.

Wir müssen den Plot über axis.plot anstoßen und nicht plt.plot, weil Matplotlib sonst die Achsenbeschriftungen und Wertebereiche ignorieren würde und auf die Standardwerte zurückgehen.

Wir hätten uns den Weg über die Achsen-Objekte auch sparen können und stattdessen den Standardplot mit entsprechenden Beschriftungen versehen können, wie es im folgenden Beispiel gezeigt wird.

Mehrere Plots

Man kann mit Matplotlib beliebig viele Kurven in eine Grafik zeichnen. Hierzu ruft man einfach mehrfach die plot-Funktion auf.

Matplotlib vergibt automatisch Farben für die verschiedenen Kurven.

x = np.linspace(0, 10, 50)
y1 = np.power(x, 2)
y2 = np.power(x, 3)

plt.plot(x, y1, label='$x^2$')
plt.plot(x, y2, label='$x^3$')

plt.xlim((1, 5))
plt.ylim((0, 30))
plt.tight_layout()

plt.xlabel('x')
plt.ylabel('y')
plt.title('Titel')
plt.legend()
plt.show()

Im Beispiel wird den Kurven eine Beschriftung mitgegebene, die als label-Parameter in der plot-Funktion angegeben wird. Das $ zeigt an, dass das Format des Labels der LaTeX-Notation folgt.

Über xlim und ylim wid der Wertebereich eingegrenzt und die Achsen werden mit xlabel und ylabel beschriftet. Die Grafik erhält ihren Titel über title. Der Befehl legend() sorgt dafür, dass die Labels der Kurven angezeigt werden.

Histogramm

Das folgende Beispiel zeichnet ein Histogramm, also eine Kurve, welche die Verteilung von Werten anzeigt. Da wir zwei Histogramme in einer Grafik zeigen vollen, legen wir mit plt.subplots(1, 2) zwei Plots nebeneinander an.

Die darzustellenden Daten werden, der Einfachheit halber, als Zufallszahlen erzeugt.

Die Funktion hist sorgt dafür, dass die Daten als Histogramm dargestellt werden, hierbei legen wir über

bins die Anzahl der Klassen
color die Farbe und
cumulative fest, ob die Daten aufsummiert werden sollen.

# Zufallsdaten erzeugen
data = np.random.randn(1000)

f, (axis1, axis2) = plt.subplots(1, 2)

# Histogram
axis1.hist(data, bins=30, color='b')

# Histogramm, kumuliert
axis2.hist(data, bins=30, color='r', cumulative=True)

plt.show()

Box-Plots

Eine weitere wichtige Darstellung sind die Boxplots auch Box-Whisker-Plot genannt. Es sind Diagramme, zur grafischen Darstellung der Verteilung eines mindestens ordinalskalierten Merkmals.

Ein Box-Blot fasst dabei verschiedene robuste Streuungs- und Lagemaße in einer Darstellung zusammen. Ein Box-Plot soll schnell einen Eindruck darüber vermitteln, in welchem Bereich die Daten liegen und wie sie sich über diesen Bereich verteilen. Deshalb werden alle Werte der sogenannten Fünf-Punkte-Zusammenfassung, also der

Median,
die zwei Quartile und
die beiden Extremwerte,

dargestellt.

samp1 = np.random.normal(loc=0., scale=1., size=100)
samp2 = np.random.normal(loc=1., scale=2., size=100)
samp3 = np.random.normal(loc=0.3, scale=1.2, size=100)

f, ax = plt.subplots(1, 1, figsize=(5,4))

ax.boxplot((samp1, samp2, samp3))
ax.set_xticklabels([ 'Probe 1', 'Probe 2', 'Probe 3' ])

plt.show()

Heatmaps

Der letzte Diagrammtyp, den wir hier behandeln wollen, ist die Heatmap. Bei dieser werden Werte auf einer zweidimensionalen Fläche angeordnet und entsprechend ihres Wertes eingefärbt.

a = np.random.random((100, 100))

plt.imshow(a)
plt.hot()
plt.colorbar()

plt.show()