Pyplot-Tutorial

Eine Einführung in die Pyplot-Schnittstelle. Bitte siehe auch Schnellstartanleitung für einen Überblick, wie Matplotlib funktioniert, und Matplotlib Application Interfaces (APIs) für eine Erklärung der Kompromisse zwischen den unterstützten Benutzer-APIs.

Einführung in Pyplot

matplotlib.pyplot ist eine Sammlung von Funktionen, die Matplotlib wie MATLAB funktionieren lassen. Jede pyplot-Funktion ändert eine Abbildung: z. B. erstellt eine Abbildung, erstellt einen Zeichenbereich in einer Abbildung, zeichnet einige Linien in einem Zeichenbereich, verziert die Grafik mit Beschriftungen usw.

In matplotlib.pyplot werden verschiedene Zustände über Funktionsaufrufe hinweg beibehalten, sodass es Dinge wie die aktuelle Abbildung und den aktuellen Zeichenbereich verfolgt und die Zeichenfunktionen an die aktuelle Achse (bitte beachte, dass wir Großbuchstaben Axes verwenden, um das Axes-Konzept zu bezeichnen, das ein zentraler Teil einer Abbildung ist und nicht nur der Plural von Achse) weitergeleitet werden.

Hinweis

Die implizite Pyplot-API ist im Allgemeinen weniger ausführlich, aber auch nicht so flexibel wie die explizite API. Die meisten der hier gezeigten Funktionsaufrufe können auch als Methoden eines Axes-Objekts aufgerufen werden. Wir empfehlen, die Tutorials und Beispiele zu durchsuchen, um zu sehen, wie dies funktioniert. Siehe Matplotlib Application Interfaces (APIs) für eine Erklärung der Kompromisse der unterstützten Benutzer-APIs.

Das Erstellen von Visualisierungen mit Pyplot ist sehr schnell

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Sie fragen sich vielleicht, warum die x-Achse von 0-3 und die y-Achse von 1-4 reicht. Wenn Sie eine einzelne Liste oder ein Array an plot übergeben, geht Matplotlib davon aus, dass es sich um eine Folge von y-Werten handelt, und generiert automatisch die x-Werte für Sie. Da Python-Bereiche bei 0 beginnen, hat der Standard-x-Vektor die gleiche Länge wie y, beginnt aber bei 0; daher sind die x-Daten [0, 1, 2, 3].

plot ist eine vielseitige Funktion und akzeptiert eine beliebige Anzahl von Argumenten. Zum Beispiel können Sie zum Plotten von x gegen y schreiben:

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])

Formatieren des Stils Ihrer Grafik

Für jedes x, y-Argumentpaar gibt es ein optionales drittes Argument, das die Formatierungszeichenkette ist, die die Farbe und den Linientyp des Plots angibt. Die Buchstaben und Symbole der Formatierungszeichenkette stammen aus MATLAB, und Sie verketten eine Farbbeschreibung mit einer Linienstilbeschreibung. Die Standardformatierungszeichenkette ist 'b-', was eine durchgezogene blaue Linie ist. Um zum Beispiel das Obige mit roten Kreisen zu plotten, würden Sie Folgendes ausgeben:

plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis((0, 6, 0, 20))
plt.show()

Siehe die Dokumentation zu plot für eine vollständige Liste der Linienstile und Formatierungszeichenketten. Die Funktion axis im obigen Beispiel nimmt eine Liste von [xmin, xmax, ymin, ymax] und gibt den Ansichtsbereich der Achsen an.

Wenn Matplotlib auf die Arbeit mit Listen beschränkt wäre, wäre es für die numerische Verarbeitung ziemlich nutzlos. Im Allgemeinen werden Sie numpy-Arrays verwenden. Tatsächlich werden alle Sequenzen intern in numpy-Arrays konvertiert. Das folgende Beispiel zeigt das Plotten mehrerer Linien mit verschiedenen Formatstilen in einem einzigen Funktionsaufruf unter Verwendung von Arrays.

import numpy as np

# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)

# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Plotten mit Schlüsselwort-Zeichenketten

Es gibt einige Fälle, in denen Daten in einem Format vorliegen, mit dem Sie über Zeichenketten auf bestimmte Variablen zugreifen können. Zum Beispiel mit strukturierten Arrays oder pandas.DataFrame.

Matplotlib ermöglicht es Ihnen, ein solches Objekt mit dem Schlüsselwortargument data bereitzustellen. Wenn angegeben, können Sie dann Diagramme mit den Zeichenketten generieren, die diesen Variablen entsprechen.

data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Plotten mit kategorischen Variablen

Es ist auch möglich, ein Diagramm mit kategorischen Variablen zu erstellen. Matplotlib ermöglicht es Ihnen, kategorische Variablen direkt an viele Plotfunktionen zu übergeben. Zum Beispiel:

names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]

plt.figure(figsize=(9, 3))

plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Steuern der Linien-Eigenschaften

Linien haben viele Attribute, die Sie einstellen können: Linienbreite, Strichmuster, Kantenglättung usw.; siehe matplotlib.lines.Line2D. Es gibt mehrere Möglichkeiten, Linien-Eigenschaften einzustellen:

• Verwenden von Schlüsselwortargumenten

  plt.plot(x, y, linewidth=2.0)
  

• Verwenden Sie die Setter-Methoden einer Line2D-Instanz. plot gibt eine Liste von Line2D-Objekten zurück; z. B. line1, line2 = plot(x1, y1, x2, y2). Im folgenden Code gehen wir davon aus, dass wir nur eine Linie haben, sodass die zurückgegebene Liste die Länge 1 hat. Wir verwenden Tupel-Entpackung mit line,, um das erste Element dieser Liste zu erhalten.

  line, = plt.plot(x, y, '-')
  line.set_antialiased(False) # turn off antialiasing
  

• Verwenden von setp. Das folgende Beispiel verwendet eine MATLAB-ähnliche Funktion, um mehrere Eigenschaften für eine Liste von Linien einzustellen. setp arbeitet transparent mit einer Liste von Objekten oder einem einzelnen Objekt. Sie können entweder Python-Schlüsselwortargumente oder MATLAB-ähnliche Zeichenketten/Wert-Paare verwenden.

  lines = plt.plot(x1, y1, x2, y2)
  # use keyword arguments
  plt.setp(lines, color='r', linewidth=2.0)
  # or MATLAB style string value pairs
  plt.setp(lines, 'color', 'r', 'linewidth', 2.0)
  

Hier sind die verfügbaren Line2D-Eigenschaften.

Eigenschaft	Wert-Typ
alpha	float
animated	[True | False]
antialiased oder aa	[True | False]
clip_box	eine matplotlib.transform.Bbox-Instanz
clip_on	[True | False]
clip_path	eine Path-Instanz und eine Transform-Instanz, ein Patch
color oder c	beliebige matplotlib-Farbe
contains	die Trefferfunktion
dash_capstyle	['butt' | 'round' | 'projecting']
dash_joinstyle	['miter' | 'round' | 'bevel']
dashes	Sequenz von Ein/Aus-Tinte in Punkten
Daten	(np.array xdata, np.array ydata)
figure	eine matplotlib.figure.Figure-Instanz
label	beliebige Zeichenkette
linestyle oder ls	[ '-' | '--' | '-.' | ':' | 'steps' | ...]
linewidth oder lw	float-Wert in Punkten
marker	[ '+' | ',' | '.' | '1' | '2' | '3' | '4' ]
markeredgecolor oder mec	beliebige matplotlib-Farbe
markeredgewidth oder mew	float-Wert in Punkten
markerfacecolor oder mfc	beliebige matplotlib-Farbe
markersize oder ms	float
markevery	[ None | Integer | (startind, stride) ]
picker	verwendet bei interaktiver Linienauswahl
pickradius	der Radius der Linien-Auswahl
solid_capstyle	['butt' | 'round' | 'projecting']
solid_joinstyle	['miter' | 'round' | 'bevel']
transform	eine matplotlib.transforms.Transform-Instanz
visible	[True | False]
xdata	np.array
ydata	np.array
zorder	beliebige Zahl

Um eine Liste der einstellbaren Linien-Eigenschaften zu erhalten, rufen Sie die Funktion setp mit einer oder mehreren Linien als Argument auf.

In [69]: lines = plt.plot([1, 2, 3])

In [70]: plt.setp(lines)
  alpha: float
  animated: [True | False]
  antialiased or aa: [True | False]
  ...snip

Arbeiten mit mehreren Abbildungen und Achsen

MATLAB und pyplot haben das Konzept der aktuellen Abbildung und der aktuellen Achse. Alle Plotfunktionen gelten für die aktuelle Achse. Die Funktion gca gibt die aktuelle Achse zurück (eine matplotlib.axes.Axes-Instanz), und gcf gibt die aktuelle Abbildung zurück (eine matplotlib.figure.Figure-Instanz). Normalerweise müssen Sie sich darum keine Sorgen machen, da dies alles im Hintergrund erledigt wird. Unten ist ein Skript, um zwei Unterdiagramme zu erstellen.

def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

Der figure-Aufruf hier ist optional, da eine Abbildung erstellt wird, wenn keine vorhanden ist, genau wie eine Achse erstellt wird (entspricht einem expliziten subplot()-Aufruf), wenn keine vorhanden ist. Der subplot-Aufruf gibt numrows, numcols, plot_number an, wobei plot_number von 1 bis numrows*numcols reicht. Die Kommas im subplot-Aufruf sind optional, wenn numrows*numcols<10. Also ist subplot(211) identisch mit subplot(2, 1, 1).

Sie können eine beliebige Anzahl von Unterdiagrammen und Achsen erstellen. Wenn Sie eine Achse manuell platzieren möchten, d. h. nicht auf einem rechteckigen Gitter, verwenden Sie axes, mit dem Sie die Position als axes([left, bottom, width, height]) angeben können, wobei alle Werte in fraktionalen (0 bis 1) Koordinaten angegeben werden. Siehe Achsen-Demo für ein Beispiel für das manuelle Platzieren von Achsen und Mehrere Unterdiagramme für ein Beispiel mit vielen Unterdiagrammen.

Sie können mehrere Abbildungen erstellen, indem Sie mehrere figure-Aufrufe mit einer steigenden Abbildungsnummer verwenden. Jede Abbildung kann natürlich so viele Achsen und Unterdiagramme enthalten, wie Ihr Herz begehrt.

import matplotlib.pyplot as plt
plt.figure(1)                # the first figure
plt.subplot(211)             # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212)             # the second subplot in the first figure
plt.plot([4, 5, 6])


plt.figure(2)                # a second figure
plt.plot([4, 5, 6])          # creates a subplot() by default

plt.figure(1)                # first figure current;
                             # subplot(212) still current
plt.subplot(211)             # make subplot(211) in the first figure
                             # current
plt.title('Easy as 1, 2, 3') # subplot 211 title

Sie können die aktuelle Abbildung mit clf und die aktuelle Achse mit cla löschen. Wenn Sie es störend finden, dass Zustände (insbesondere das aktuelle Bild, die aktuelle Abbildung und die aktuelle Achse) im Hintergrund für Sie verwaltet werden, verzweifeln Sie nicht: Dies ist nur ein dünner zustandsbehafteter Wrapper um eine objektorientierte API, die Sie stattdessen verwenden können (siehe Künstler-Tutorial).

Wenn Sie viele Abbildungen erstellen, müssen Sie noch eines beachten: Der für eine Abbildung benötigte Speicher wird erst vollständig freigegeben, wenn die Abbildung mit close explizit geschlossen wird. Das Löschen aller Referenzen auf die Abbildung und/oder die Verwendung des Fenstermanagers zum Beenden des Fensters, in dem die Abbildung auf dem Bildschirm erscheint, reicht nicht aus, da Pyplot interne Referenzen beibehält, bis close aufgerufen wird.

Arbeiten mit Text

text kann verwendet werden, um Text an einer beliebigen Stelle hinzuzufügen, und xlabel, ylabel und title werden verwendet, um Text an den angegebenen Stellen hinzuzufügen (siehe Text in Matplotlib für ein detaillierteres Beispiel).

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()

Alle text-Funktionen geben eine matplotlib.text.Text-Instanz zurück. Genau wie bei den Linien oben können Sie die Eigenschaften anpassen, indem Sie Schlüsselwortargumente an die Textfunktionen übergeben oder setp verwenden.

t = plt.xlabel('my data', fontsize=14, color='red')

Diese Eigenschaften werden detaillierter in Texteigenschaften und Layout behandelt.

Verwenden von mathematischen Ausdrücken in Text

Matplotlib akzeptiert TeX-Gleichungsausdrücke in jedem Textausdruck. Zum Beispiel, um den Ausdruck \(\sigma_i=15\) im Titel zu schreiben, können Sie einen TeX-Ausdruck in Dollarzeichen schreiben.

plt.title(r'$\sigma_i=15$')

Das r vor der Titelzeichenkette ist wichtig – es bedeutet, dass die Zeichenkette eine *Rohzeichenkette* ist und Rückstriche nicht als Python-Escapes behandelt werden sollen. Matplotlib verfügt über einen integrierten TeX-Ausdruck-Parser und eine Layout-Engine und liefert eigene mathematische Schriftarten – Details finden Sie unter Mathematische Ausdrücke schreiben. Somit können Sie mathematischen Text plattformübergreifend verwenden, ohne eine TeX-Installation zu benötigen. Für diejenigen, die LaTeX und dvipng installiert haben, können Sie auch LaTeX zur Formatierung Ihres Textes verwenden und die Ausgabe direkt in Ihre angezeigten Grafiken oder gespeicherten Postscript-Dateien integrieren – siehe Text-Rendering mit LaTeX.

Textbeschriftungen

Die oben gezeigte Verwendung der grundlegenden text-Funktion platziert Text an einer beliebigen Position auf den Achsen. Eine häufige Verwendung von Text ist die Beschriftung eines Merkmals der Grafik, und die Methode annotate bietet Hilfsfunktionen, um Beschriftungen zu vereinfachen. Bei einer Beschriftung sind zwei Punkte zu beachten: die zu beschriftende Position, dargestellt durch das Argument xy, und die Position des Textes xytext. Beide Argumente sind (x, y)-Tupel.

ax = plt.subplot()

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2)

plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
             arrowprops=dict(facecolor='black', shrink=0.05),
             )

plt.ylim(-2, 2)
plt.show()

In diesem einfachen Beispiel befinden sich sowohl die xy (Pfeilspitze) als auch die xytext (Textposition) in Datenkoordinaten. Es gibt eine Vielzahl anderer Koordinatensysteme, die Sie wählen können – siehe Grundlegende Beschriftung und Fortgeschrittene Beschriftung für Details. Weitere Beispiele finden Sie unter Grafiken beschriften.

Logarithmische und andere nicht-lineare Achsen

matplotlib.pyplot unterstützt nicht nur lineare Achsenskalen, sondern auch logarithmische und Logit-Skalen. Dies wird häufig verwendet, wenn Daten viele Größenordnungen umfassen. Das Ändern der Skala einer Achse ist einfach:

plt.xscale('log')

Ein Beispiel für vier Grafiken mit denselben Daten und unterschiedlichen Skalen für die y-Achse ist unten dargestellt.

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the open interval (0, 1)
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure()

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)

# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)

# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.01)
plt.title('symlog')
plt.grid(True)

# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
                    wspace=0.35)

plt.show()

Es ist auch möglich, eigene Skalen hinzuzufügen. Details finden Sie unter matplotlib.scale.