Pyplot-Tutorial

Eine Einführung in die Pyplot-Schnittstelle. Bitte beachten Sie auch die Kurzanleitung für einen Überblick über die Funktionsweise von Matplotlib und Matplotlib Application Interfaces (APIs) für eine Erläuterung der Kompromisse zwischen den unterstützten Benutzer-APIs.

Einführung in Pyplot

matplotlib.pyplotist eine Sammlung von Funktionen, die dafür sorgen, dass Matplotlib wie MATLAB funktioniert. Jede pyplotFunktion nimmt eine Änderung an einer Figur vor: z. B. erstellt sie eine Figur, erstellt einen Zeichenbereich in einer Figur, zeichnet einige Linien in einem Zeichenbereich, verziert den Plot mit Beschriftungen usw.

In matplotlib.pyplotverschiedenen Zuständen werden Funktionsaufrufe beibehalten, sodass Dinge wie die aktuelle Figur und der Plotbereich verfolgt werden und die Plotfunktionen auf die aktuellen Achsen gerichtet sind (bitte beachten Sie, dass sich "Achsen" hier und an den meisten Stellen in der Dokumentation bezieht auf den Achsenteil einer Figur und nicht auf den streng mathematischen Begriff für mehr als eine Achse).

Notiz

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 von einem AxesObjekt aufgerufen werden. Wir empfehlen, die Tutorials und Beispiele zu durchsuchen, um zu sehen, wie das funktioniert. Siehe Matplotlib-Anwendungsschnittstellen (APIs) für eine Erläuterung des Kompromisses der unterstützten Benutzer-APIs.

Das Generieren 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 für plotbereitstellen, 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 mit 0 beginnen, hat der Standard-x-Vektor die gleiche Länge wie y, beginnt aber mit 0. Daher sind die x-Daten .[0, 1, 2, 3]

plotist eine vielseitige Funktion und akzeptiert eine beliebige Anzahl von Argumenten. Um beispielsweise x gegen y zu zeichnen, können Sie schreiben:

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

[<matplotlib.lines.Line2D object at 0x7f2cf9d23b20>]

Den Stil Ihres Plots formatieren

Für jedes x, y-Argumentpaar gibt es ein optionales drittes Argument, bei dem es sich um die Formatzeichenfolge handelt, die die Farbe und den Linientyp des Diagramms angibt. Die Buchstaben und Symbole des Format-Strings stammen aus MATLAB, und Sie verketten einen Farb-String mit einem Linienstil-String. Die standardmäßige Formatzeichenfolge ist „b-“, was eine durchgezogene blaue Linie ist. Um beispielsweise das Obige mit roten Kreisen darzustellen, würden Sie ausgeben

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

plotEine vollständige Liste der Linienstile und Formatzeichenfolgen finden Sie in der Dokumentation. Die axisFunktion im obigen Beispiel nimmt eine Liste von und spezifiziert das Ansichtsfenster der Achsen.[xmin, xmax, ymin, ymax]

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 veranschaulicht das Zeichnen mehrerer Linien mit unterschiedlichen Formatstilen in einem Funktionsaufruf mithilfe 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-Strings

Es gibt einige Fälle, in denen Sie Daten in einem Format haben, mit dem Sie mit Zeichenfolgen auf bestimmte Variablen zugreifen können. Zum Beispiel mit numpy.recarrayoder pandas.DataFrame.

Mit Matplotlib können Sie ein solches Objekt mit dem dataSchlüsselwortargument bereitstellen. Falls vorhanden, können Sie Diagramme mit den Zeichenfolgen erstellen, 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 kategorialen Variablen

Es ist auch möglich, ein Diagramm mit kategorialen Variablen zu erstellen. Mit Matplotlib können Sie kategoriale Variablen direkt an viele Plotfunktionen ü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()

Linieneigenschaften steuern

Linien haben viele Attribute, die Sie festlegen können: Linienbreite, Strichstil, Antialiasing usw.; siehe matplotlib.lines.Line2D. Es gibt mehrere Möglichkeiten, Linieneigenschaften festzulegen

• Verwenden Sie Schlüsselwortargumente:

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

• Verwenden Sie die Setter-Methoden einer Line2DInstanz. plotgibt eine Liste von Line2DObjekten zurück; zB . Im folgenden Code nehmen wir an, dass wir nur eine Zeile haben, sodass die zurückgegebene Liste die Länge 1 hat. Wir verwenden das Tupel-Entpacken mit , um das erste Element dieser Liste zu erhalten:line1, line2 = plot(x1, y1, x2, y2)line,

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

• Verwenden Sie setp. Das folgende Beispiel verwendet eine Funktion im MATLAB-Stil, um mehrere Eigenschaften für eine Liste von Zeilen festzulegen. setparbeitet transparent mit einer Liste von Objekten oder einem einzelnen Objekt. Sie können entweder Python-Schlüsselwortargumente oder String/Wert-Paare im MATLAB-Stil 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 Line2DEigenschaften.

Eigentum	Werttyp
Alpha	schweben
animiert	[Wahr | FALSCH]
Antialiased oder aa	[Wahr | FALSCH]
clip_box	eine matplotlib.transform.Bbox-Instanz
clip_on	[Wahr | FALSCH]
clip_path	eine Path-Instanz und eine Transform-Instanz, ein Patch
Farbe oder c	jede Matplotlib-Farbe
enthält	die Treffertestfunktion
dash_capstyle	[ 'butt'| 'round'| 'projecting']
dash_joinstyle	[ 'miter'| 'round'| 'bevel']
Striche	Sequenz von Ein/Aus-Tinte in Punkten
Daten	(np.array xdata, np.array ydata)
Zahl	eine matplotlib.figure.Figure-Instanz
Etikett	irgendeine Zeichenfolge
Linienstil oder ls	[ '-'| '--'| '-.'| ':'| 'steps'| ...]
Linienbreite oder lw	Float-Wert in Punkten
Marker	[ '+'| ','| '.'| '1'| '2'| '3'| '4']
markeredgecolor oder mec	jede Matplotlib-Farbe
markeredgewidth oder mew	Float-Wert in Punkten
markerfacecolor oder mfc	jede Matplotlib-Farbe
Markergröße oder ms	schweben
Markevery	[ Keine | Ganzzahl | (starten, schreiten) ]
Pflücker	Wird bei der interaktiven Linienauswahl verwendet
Auswahlradius	der Linienauswahlradius
solid_capstyle	[ 'butt'| 'round'| 'projecting']
solid_joinstyle	[ 'miter'| 'round'| 'bevel']
verwandeln	eine matplotlib.transforms.Transform-Instanz
sichtbar	[Wahr | FALSCH]
xdaten	np.array
ydaten	np.array
zorder	irgendeine Nummer

Um eine Liste der einstellbaren Linieneigenschaften zu erhalten, rufen Sie die setpFunktion 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 Figuren und Achsen

MATLAB und pyplot, haben das Konzept der aktuellen Figur und der aktuellen Achsen. Alle Plotfunktionen gelten für die aktuellen Achsen. Die Funktion gcagibt die aktuellen Achsen (eine matplotlib.axes.AxesInstanz) und gcfdie aktuelle Figur (eine matplotlib.figure.FigureInstanz) zurück. Normalerweise müssen Sie sich darüber keine Gedanken machen, da sich alles hinter den Kulissen erledigt. Unten ist ein Skript zum Erstellen von zwei Subplots.

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 figureAufruf hier ist optional, da eine Figur erstellt wird, wenn keine existiert, genauso wie eine Achse erstellt wird (äquivalent zu einem expliziten subplot()Aufruf), wenn keine existiert. Der subplotAufruf gibt an, wo von 1 bis reicht . Die Kommas im Aufruf sind optional, wenn . Ist also identisch mit .numrows, numcols, plot_numberplot_numbernumrows*numcolssubplotnumrows*numcols<10subplot(211)subplot(2, 1, 1)

Sie können beliebig viele Subplots und Achsen erstellen. Wenn Sie eine Achse manuell platzieren möchten, dh nicht auf einem rechteckigen Raster, verwenden axesSie , mit dem Sie die Position als Stelle angeben können, an der alle Werte in Bruchkoordinaten (0 bis 1) stehen. Siehe Axes Demo für ein Beispiel zum manuellen Platzieren von Achsen und Multiple Subplots für ein Beispiel mit vielen Subplots.axes([left, bottom, width, height])

Sie können mehrere Figuren erstellen, indem Sie mehrere figureAufrufe mit einer aufsteigenden Figurennummer verwenden. Natürlich kann jede Figur so viele Achsen und Nebenhandlungen 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)                # figure 1 current; subplot(212) still current
plt.subplot(211)             # make subplot(211) in figure1 current
plt.title('Easy as 1, 2, 3') # subplot 211 title

Sie können die aktuelle Figur mit clf und die aktuellen Achsen mit löschen cla. Wenn Sie es ärgerlich finden, dass Zustände (insbesondere das aktuelle Bild, die Zahl und die Achsen) hinter den Kulissen für Sie verwaltet werden, verzweifeln Sie nicht: Dies ist nur ein dünner zustandsbehafteter Wrapper um eine objektorientierte API, den Sie stattdessen verwenden können (siehe Artist-Tutorial )

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

Mit Text arbeiten

textkönnen verwendet werden, um Text an einer beliebigen Stelle hinzuzufügen, und xlabel, ylabelund titlewerden verwendet, um Text an den angegebenen Stellen hinzuzufügen (siehe Text in Matplotlib-Plots 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 textFunktionen geben eine matplotlib.text.Text Instanz zurück. Genau wie bei den obigen Zeilen können Sie die Eigenschaften anpassen, indem Sie Schlüsselwortargumente an die Textfunktionen übergeben oder verwenden setp:

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

Diese Eigenschaften werden ausführlicher in Texteigenschaften und Layout behandelt .

Mathematische Ausdrücke in Text verwenden

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

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

Das rVoranstellen des Titel-Strings ist wichtig – es bedeutet, dass der String ein Roh -String ist und Backslashes nicht als Python-Escapes behandelt werden sollen. matplotlib hat einen eingebauten TeX-Ausdrucksparser und eine Layout-Engine und bringt seine eigenen mathematischen Schriftarten mit – für Details siehe 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 verwenden, um Ihren Text zu formatieren und die Ausgabe direkt in Ihre Anzeigeabbildungen oder gespeichertes Postscript einzufügen – siehe Textwiedergabe mit LaTeX .

Text kommentieren

Die Verwendung der textobigen Grundfunktion platziert Text an einer beliebigen Position auf den Achsen. Eine übliche Verwendung für Text besteht darin, einige Merkmale des Diagramms zu kommentieren, und die annotateMethode bietet Hilfsfunktionen, um das Kommentieren zu vereinfachen. Bei einer Anmerkung müssen zwei Punkte berücksichtigt werden: die durch das Argument dargestellte kommentierte xyStelle und die Stelle des Textes xytext. Beide Argumente sind Tupel.(x, y)

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 sind sowohl die xy(Pfeilspitze) als auch die xytext Positionen (Textposition) in Datenkoordinaten. Es gibt eine Vielzahl anderer Koordinatensysteme, die man auswählen kann – siehe Grundlegende Anmerkungen und Erweiterte Anmerkungen für Details. Weitere Beispiele finden Sie unter Diagramme kommentieren .

Logarithmische und andere nichtlineare Achsen

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

plt.xscale('log')

Ein Beispiel für vier Diagramme mit denselben Daten und unterschiedlichen Maßstäben 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, Ihre eigene Skala hinzuzufügen, siehe matplotlib.scalefür Details.