Werkzeugkiste - matplotlib
Dieses Notizbuch zeigt, wie Sie mit der matplotlib-Bibliothek schöne Grafiken zeichnen.
Stellen wir zunächst sicher, dass dieses Notebook sowohl in Python 2 als auch in Python 3 gut funktioniert:
In [ ]:
from __future__ import division, print_function, unicode_literals
Zuerst müssen wir die matplotlib Bibliothek importieren.
In [ ]:
import matplotlib
Matplotlib kann Diagramme mithilfe verschiedener Backend-Grafikbibliotheken wie Tk, wxPython usw. ausgeben. Wenn Sie Python über die Befehlszeile ausführen, werden die Diagramme normalerweise in einem separaten Fenster angezeigt. In einem Jupyter-Notizbuch können wir die Grafiken einfach im Notizbuch selbst ausgeben, indem wir den magischen Befehl % matplotlib inline ausführen.
In [ ]:
%matplotlib inline
# matplotlib.use("TKAgg") # Verwenden Sie dies stattdessen in Ihrem Programm, wenn Sie Tk als Grafik-Backend verwenden möchten.
Zeichnen wir nun unser erstes Diagramm!
In [ ]:
import matplotlib.pyplot as plt
plt.plot([1, 3, 6, 9, 5, 4,9])
plt.show()
Ja, durch das Aufrufen der Funktion plot mit einigen Daten und dem Aufrufen der Funktion show, wird die Grafik gezeichnet.!
Wenn der Plotfunktion ein Datenarray zugewiesen wird, werden die als Koordinaten auf der vertikalen Achse und nur der Index jedes Datenpunkts im Array (Achtung: beginnt mit 0) als horizontale Koordinate verwendet.
Sie können auch zwei Arrays bereitstellen: eines für die horizontale Achse x und das zweite für die vertikale Achse y:
In [ ]:
plt.plot([-3, -2, 5, 0, 2, 4], [1, 6, 4, 3, 2, 1])
plt.show()
Die Achsen passen sich automatisch dem Umfang der Daten an.
Wir möchten dem Diagramm etwas mehr Raum geben, also rufen wir die
Funktion axis auf, um die Ausdehnung jeder Achse [xmin, xmax, ymin, ymax] zu ändern.
In [ ]:
plt.plot([-3, -2, 5, 0, 2, 4], [1, 6, 4, 3, 2, 1])
plt.axis([-4, 6, 0, 7])
plt.show()
Zeichnen wir nun eine mathematische Funktion. Wir verwenden die linspace -Funktion von NumPy, um ein Array x mit 500 Float Werten im Bereich von -2 bis 2 zu erstellen. Dann erstellen wir ein zweites Arrayy, das als Quadrat von x berechnet wird (um mehr über NumPy zu erfahren, lesen Sie das Numpy Tutorial (numpy-werkzeugkiste-10.ipynb)).
In [ ]:
import numpy as np
x = np.linspace(-2, 2, 500)
y = x**2+4
plt.plot(x, y)
plt.axis([-3, 3, 0, 10])
plt.show()
Das ist ein bisschen einfach, fügen wir einen Titel sowie x- und y-Beschriftungen hinzu und zeichnen ein Raster.
In [ ]:
plt.plot(x, y)
plt.title("Parabel y=x²+4")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.show()
Standardmäßig zeichnet matplotlib eine Linie zwischen aufeinanderfolgenden Punkten.
In [ ]:
plt.plot([0, 100, 100, 0, 0, 100, 50, 0, 100], [0, 0, 100, 100, 0, 100, 130, 100, 0])
plt.axis([-10, 110, -10, 140])
plt.show()
Sie können ein drittes Argument übergeben, um den Stil und die Farbe der Linie zu ändern. Zum Beispiel bedeutet "g--" "grüne gestrichelte Linie".
In [ ]:
plt.plot([0, 100, 100, 0, 0, 100, 50, 0, 100], [0, 0, 100, 100, 0, 100, 130, 100, 0], "g--")
plt.axis([-10, 110, -10, 140])
plt.show()
Sie können ganz einfach mehrere Linien in einem Diagramm zeichnen: Übergeben Sie einfach x1, y1, [style1], x2, y2, [style2], ...
Beispielsweise:
In [ ]:
plt.plot([0, 100, 100, 0, 0], [0, 0, 100, 100, 0], "r-", [0, 100, 50, 0, 100], [0, 100, 130, 100, 0], "g--")
plt.axis([-10, 110, -10, 140])
plt.show()
Oder rufen Sie plot einfach mehrmals auf, bevor Sie show aufrufen.
In [ ]:
plt.plot([0, 100, 100, 0, 0], [0, 0, 100, 100, 0], "r-")
plt.plot([0, 100, 50, 0, 100], [0, 100, 130, 100, 0], "g--")
plt.axis([-10, 110, -10, 140])
plt.show()
Sie können auch einfache Punkte anstelle von Linien zeichnen. Hier ist ein Beispiel mit grünen Strichen, rot gepunkteten Linien und blauen Dreiecken. Die vollständige Liste der Stil- und Farboptionen finden Sie in der Dokumentation.
In [ ]:
x = np.linspace(-1.4, 1.4, 30)
plt.plot(x, x, 'g--', x, x**2, 'r:', x, x**3, 'b^', x, x**4, 'm o')
plt.show()
Die Plotfunktion gibt eine Liste von Line2D -Objekten zurück (eines für jede Zeile). Sie können zusätzliche Attribute für diese Linien festlegen, z. B. die Linienbreite, den Strichstil oder die Alpha-Ebene. Die vollständige Liste der Attribute finden Sie in der Dokumentation .
In [ ]:
x = np.linspace(-1.4, 1.4, 30)
line1, line2, line3 = plt.plot(x, x, 'g--', x, x**2, 'r:', x, x**3, 'b^')
line1.set_linewidth(3.0)
line1.set_dash_capstyle("round")
line3.set_alpha(0.2)
plt.show()
Das Speichern einer Figur auf der Festplatte ist so einfach wie das Aufrufen von savefig mit dem Namen der Datei (oder eines Dateiobjekts). Die verfügbaren Bildformate hängen vom verwendeten Grafik-Backend ab.
Die Dokumentation finden Sie hier .
In [ ]:
x = np.linspace(-1.4, 1.4, 30)
plt.plot(x, x**2)
plt.savefig("my_square_function.png", transparent=True)
Eine Matplotlib-Grafik kann mehrere Subplots enthalten. Diese Subplots sind in einem Raster organisiert. Um ein Subplot zu erstellen, rufen Sie einfach die Funktion subplot auf und geben Sie die Anzahl der Zeilen und Spalten in der Abbildung sowie den Index des Unterplots an, auf den Sie zeichnen möchten (beginnend mit 1, dann von links nach rechts und von oben nach unten) ). Beachten Sie, dass pyplot den aktuell aktiven Subplot verfolgt (auf den Sie durch Aufrufen von plt.gca () verweisen können). Wenn Sie also die Funktion plot aufrufen, wird auf den Unterplot active zurückgegriffen.
In [ ]:
x = np.linspace(-1.4, 1.4, 30)
plt.subplot(2, 2, 1) # 2 rows, 2 columns, 1st subplot = top left
plt.plot(x, x)
plt.subplot(2, 2, 2) # 2 rows, 2 columns, 2nd subplot = top right
plt.plot(x, x**2)
plt.subplot(2, 2, 3) # 2 rows, 2 columns, 3rd subplot = bottow left
plt.plot(x, x**3)
plt.subplot(2, 2, 4) # 2 rows, 2 columns, 4th subplot = bottom right
plt.plot(x, x**4)
plt.show()
subplot(223) ist eine Kurzschreibweise für subplot(2, 2, 3).Es ist einfach, Subplots zu erstellen, die sich über mehrere Rasterzellen erstrecken:
In [ ]:
plt.subplot(2, 2, 1) # 2 rows, 2 columns, 1st subplot = top left
plt.plot(x, x)
plt.subplot(2, 2, 2) # 2 rows, 2 columns, 2nd subplot = top right
plt.plot(x, x**2)
plt.subplot(2, 1, 2) # 2 rows, *1* column, 2nd subplot = bottom
plt.plot(x, x**3)
plt.show()
Wenn Sie eine komplexere Subplot-Positionierung benötigen, können Sie subplot2grid anstelle von subplot verwenden. Sie geben die Anzahl der Zeilen und Spalten im Raster an, dann die Position Ihres Unterplots in diesem Raster (oben links = (0,0)) und optional die Anzahl der Zeilen und / oder Spalten, die es umfasst. Beispielsweise:
In [ ]:
plt.subplot2grid((3,3), (0, 0), rowspan=2, colspan=2)
plt.plot(x, x**2)
plt.subplot2grid((3,3), (0, 2))
plt.plot(x, x**3)
plt.subplot2grid((3,3), (1, 2), rowspan=2)
plt.plot(x, x**4)
plt.subplot2grid((3,3), (2, 0), colspan=2)
plt.plot(x, x**5)
plt.show()
Wenn Sie noch mehr Flexibilität bei der Positionierung von Subplots benötigen, lesen Sie die GridSpec-Dokumentation.
Es ist auch möglich, mehrere Grafiken zu zeichnen. Jede Grafik kann eine oder mehrere Subplots enthalten. Standardmäßig erstellt matplotlib automatisch figure (1). Wenn Sie die Grafik wechseln, verfolgt pyplot die aktuell aktive Figur (auf die Sie durch Aufrufen von plt.gcf () verweisen können), und der aktive SubplotUnterzeichnung dieser Grafik wird zum aktuellen Subplot.
Beispiel:
In [ ]:
x = np.linspace(-1.4, 1.4, 30)
plt.figure(1)
plt.subplot(211)
plt.plot(x, x**2)
plt.title("Quadrat und Kubisch")
plt.subplot(212)
plt.plot(x, x**3)
plt.figure(2, figsize=(10, 5))
plt.subplot(121)
plt.plot(x, x**4)
plt.title("y = x**4")
plt.subplot(122)
plt.plot(x, x**5)
plt.title("y = x**5")
plt.figure(1) # zurück zu figure 1, aktueller subplot ist 212 (unten) - es wird die rote Linie gezeichnet
plt.plot(x, -x**3, "r:")
plt.figure(2) # zurück zu figure 2, aktueller subplot ist 122 (unten rechts) - es wird die rote Linie gezeichnet
plt.plot(x, x**5+1, "r:")
plt.show()
For consistency, we will continue to use pyplot's state machine in the rest of this tutorial, but we recommend using the object-oriented interface in your programs.
There is some confusion around the relationship between pylab, pyplot and matplotlib. It's simple: matplotlib is the full library, it contains everything including pylab and pyplot.
Pyplot provides a number of tools to plot graphs, including the state-machine interface to the underlying object-oriented plotting library.
Pylab is a convenience module that imports matplotlib.pyplot and NumPy in a single name space. You will find many examples using pylab, but it is no longer recommended (because explicit imports are better than implicit ones).
Sie können Text aufrufen, um an einer beliebigen Stelle im Diagramm Text hinzuzufügen. Geben Sie einfach die horizontalen und vertikalen Koordinaten und den Text sowie optional einige zusätzliche Attribute an. Jeder Text in matplotlib kann TeX-Gleichungsausdrücke enthalten. Weitere Informationen finden Sie in der Dokumentation
Beispiel:
In [ ]:
x = np.linspace(-1.5, 1.5, 30)
px = 0.8
py = px**2
plt.plot(x, x**2, "b-", px, py, "ro")
plt.text(0, 1.5, "Quadratische Funktion\n$y = x^2$", fontsize=20, color='blue', horizontalalignment="center")
plt.text(px - 0.08, py, "Gesuchter Punkt", ha="right", weight="heavy")
plt.text(px, py, "x = %0.2f\ny = %0.2f"%(px, py), rotation=50, color='gray')
plt.show()
ha ist ein alias für horizontalalignmentWeitere Texteigenschaften finden Sie in der Dokumentation.
Es ist ziemlich häufig, Elemente eines Diagramms zu kommentieren, wie z. B. den schönen Punkt oben. Die Funktion annotate macht dies einfach: Geben Sie einfach die Position des interessierenden Punkts und die Position des Textes sowie optional einige zusätzliche Attribute für den Text und den Pfeil an.
In [ ]:
plt.plot(x, x**2, px, py, "ro")
plt.annotate("Gesuchter Punkt", xy=(px, py), xytext=(px-1.5,py+0.5),
color="green", weight="heavy", fontsize=14,
arrowprops={"facecolor": "lightgreen"})
plt.show()
Sie können Ihrem Text auch einen Begrenzungsrahmen hinzufügen, indem Sie das Attribut bbox verwenden:
In [ ]:
plt.plot(x, x**2, px, py, "ro")
bbox_props = dict(boxstyle="rarrow,pad=0.3", ec="b", lw=2, fc="lightblue")
plt.text(px-0.2, py, "Gesuchter Punkt", bbox=bbox_props, ha="right")
bbox_props = dict(boxstyle="round4,pad=1,rounding_size=0.2", ec="black", fc="#EEEEFF", lw=5)
plt.text(0, 1.5, "Quadratische Funktion\n$y = x^2$", fontsize=20, color='black', ha="center", bbox=bbox_props)
plt.show()
Nur zum Spaß, wenn Sie einen Plot im xkcd -Stil möchten, zeichnen Sie einfach in einem Abschnitt mit plt.xkcd ():
In [ ]:
with plt.xkcd():
plt.plot(x, x**2, px, py, "ro")
bbox_props = dict(boxstyle="rarrow,pad=0.3", ec="b", lw=2, fc="lightblue")
plt.text(px-0.2, py, "Gesuchter Punkt", bbox=bbox_props, ha="right")
bbox_props = dict(boxstyle="round4,pad=1,rounding_size=0.2", ec="black", fc="#EEEEFF", lw=5)
plt.text(0, 1.5, "Quadratische Funktion\n$y = x^2$", fontsize=20, color='black', ha="center", bbox=bbox_props)
plt.show()
In [ ]:
x = np.linspace(-1.4, 1.4, 50)
plt.plot(x, x**2, "r--", label="Quadratische Funktion")
plt.plot(x, x**3, "g-", label="Kubische Funktion")
plt.legend(loc="best")
plt.grid(True)
plt.show()
In [ ]:
x = np.linspace(0.1, 15, 500)
y = x**3/np.exp(2*x)
plt.figure(1)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)
plt.figure(2)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)
plt.figure(3)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
plt.figure(4)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthreshy=0.05)
plt.title('symlog')
plt.grid(True)
plt.show()
In [ ]:
x = np.linspace(-2, 2, 100)
plt.figure(1, figsize=(15,10))
plt.subplot(131)
plt.plot(x, x**3)
plt.grid(True)
plt.title("Standard Beschriftung")
ax = plt.subplot(132)
plt.plot(x, x**3)
ax.xaxis.set_ticks(np.arange(-2, 2, 1))
plt.grid(True)
plt.title("Manuelle Beschriftung auf der x-Achse")
ax = plt.subplot(133)
plt.plot(x, x**3)
plt.minorticks_on()
ax.tick_params(axis='x', which='minor', bottom='off')
ax.xaxis.set_ticks([-2, 0, 1, 2])
ax.yaxis.set_ticks(np.arange(-5, 5, 1))
ax.yaxis.set_ticklabels(["min", -4, -3, -2, -1, 0, 1, 2, 3, "max"])
plt.title("Manuelle Beschriftung\n(plus min/max) auf der y-Achse")
plt.grid(True)
plt.show()
In [ ]:
radius = 1
theta = np.linspace(0, 2*np.pi*radius, 1000)
plt.subplot(111, projection='polar')
plt.plot(theta, np.sin(5*theta), "g-")
plt.plot(theta, 0.5*np.cos(20*theta), "b-")
plt.show()
-Diagrammen ist recht einfach. Sie müssen Axes3D importieren, das die "3d" -Projektion registriert. Erstellen Sie dann einen Subplot, in der die projection auf "3d" gesetzt wird. Dies gibt ein Axes3DSubplot-Objekt zurück, mit dem Sie plot_surface aufrufen können, wobei x-, y- und z-Koordinaten sowie optionale Attribute angegeben werden.
In [ ]:
from mpl_toolkits.mplot3d import Axes3D
x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
figure = plt.figure(1, figsize = (12, 6))
subplot3d = plt.subplot(111, projection='3d')
surface = subplot3d.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=matplotlib.cm.coolwarm, linewidth=0.1)
plt.show()
Eine andere Möglichkeit, dieselben Daten anzuzeigen, ist ein Konturdiagramm.
In [ ]:
plt.contourf(X, Y, Z, cmap=matplotlib.cm.coolwarm)
plt.colorbar()
plt.show()
Geben Sie zum Zeichnen eines Streudiagramms einfach die x- und y-Koordinaten der Punkte an.
In [ ]:
from numpy.random import rand
x, y = rand(2, 100)
plt.scatter(x, y)
plt.show()
Optional können Sie auch die Skalierung jedes Punkts angeben.
In [ ]:
x, y, scale = rand(3, 100)
scale = 500 * scale ** 5
plt.scatter(x, y, s=scale)
plt.show()
Und wie üblich können Sie eine Reihe anderer Attribute festlegen, z. B. die Füll- und Kantenfarben sowie die Alpha-Ebene.
In [ ]:
for color in ['red', 'green', 'blue']:
n = 100
x, y = rand(2, n)
scale = 500.0 * rand(n) ** 5
plt.scatter(x, y, s=scale, c=color, alpha=0.3, edgecolors='blue')
plt.grid(True)
plt.show()
Sie können Linien einfach mit der Funktion plot zeichnen, wie wir es bisher getan haben. Es ist jedoch häufig zweckmäßig, eine Dienstprogrammfunktion zu erstellen, die eine (scheinbar) unendliche Linie über den Graphen zeichnet, wenn eine Steigung und ein Achsenabschnitt gegeben sind. Sie können auch die Funktionen hlines und vlines verwenden, mit denen horizontale und vertikale Liniensegmente dargestellt werden.
Beispielsweise:
In [ ]:
from numpy.random import randn
def plot_line(axis, slope, intercept, **kargs):
xmin, xmax = axis.get_xlim()
plt.plot([xmin, xmax], [xmin*slope+intercept, xmax*slope+intercept], **kargs)
x = randn(1000)
y = 0.5*x + 5 + randn(1000)*2
plt.axis([-2.5, 2.5, -5, 15])
plt.scatter(x, y, alpha=0.2)
plt.plot(1, 0, "ro")
plt.vlines(1, -5, 0, color="red")
plt.hlines(0, -2.5, 1, color="red")
plot_line(axis=plt.gca(), slope=0.5, intercept=5, color="magenta")
plt.grid(True)
plt.show()
In [ ]:
data = [1, 1.1, 1.8, 2, 2.1, 3.2, 3, 3, 3, 3]
plt.subplot(211)
plt.hist(data, bins = 10, rwidth=0.8)
plt.subplot(212)
plt.hist(data, bins = [1, 1.5, 2, 2.5, 3], rwidth=0.95)
plt.xlabel("Werte")
plt.ylabel("Häufigkeit")
plt.show()
Weitere Beispiele für Histogramme
In [ ]:
data1 = np.random.randn(400)
data2 = np.random.randn(500) + 3
data3 = np.random.randn(450) + 6
data4a = np.random.randn(200) + 9
data4b = np.random.randn(100) + 10
plt.hist(data1, bins=5, color='g', alpha=0.75, label='bar hist') # default histtype='bar'
plt.hist(data2, color='b', alpha=0.65, histtype='stepfilled', label='stepfilled hist')
plt.hist(data3, color='r', histtype='step', label='step hist')
plt.hist((data4a, data4b), color=('r','m'), alpha=0.55, histtype='barstacked', label=('barstacked a', 'barstacked b'))
plt.xlabel("Werte")
plt.ylabel("Häufigkeit")
plt.legend()
plt.grid(True)
plt.show()
Jetzt kennen Sie einige Grundlagen von matplotlib, aber es stehen noch viele weitere Optionen zur Verfügung. Der beste Weg, um mehr zu erfahren, ist, die Galerie zu besuchen, sich die Bilder anzusehen, ein Beispiel auszuwählen, die Sie interessiert, und dann einfach den Code in ein Jupyter Notebook zu kopieren und damit herumspielen.
In [ ]: