Schnellstartanleitung

Dieses Tutorial behandelt einige grundlegende Verwendungsmuster und Best Practices, die Ihnen den Einstieg in Matplotlib erleichtern.

import matplotlib.pyplot as plt
import numpy as np

Ein einfaches Beispiel

Matplotlib zeichnet Ihre Daten auf Figure (z. B. Fenster, Jupyter-Widgets usw.), von denen jede eine oder mehrere Axes enthalten kann, einen Bereich, in dem Punkte anhand von x-y-Koordinaten (oder Theta-R in einem Polarkoordinatendiagramm, x-y-z in einem 3D-Diagramm usw.) spezifiziert werden können. Der einfachste Weg, eine Figure mit einer Axes zu erstellen, ist die Verwendung von pyplot.subplots. Wir können dann Axes.plot verwenden, um einige Daten auf der Axes zu zeichnen, und show, um die Figure anzuzeigen

fig, ax = plt.subplots()             # Create a figure containing a single Axes.
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])  # Plot some data on the Axes.
plt.show()                           # Show the figure.

Abhängig von der Umgebung, in der Sie arbeiten, kann plt.show() weggelassen werden. Dies ist zum Beispiel bei Jupyter-Notebooks der Fall, die automatisch alle in einer Codezelle erstellten Figuren anzeigen.

Teile einer Figure

Hier sind die Komponenten einer Matplotlib-Figure.

Figure

Die **gesamte** Figure. Die Figure verfolgt alle untergeordneten Axes, eine Gruppe von "speziellen" Artists (Titel, Figurenbeschriftungen, Farbbalken usw.) und sogar verschachtelte Subfiguren.

Typischerweise erstellen Sie eine neue Figure über eine der folgenden Funktionen

fig = plt.figure()             # an empty figure with no Axes
fig, ax = plt.subplots()       # a figure with a single Axes
fig, axs = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes
# a figure with one Axes on the left, and two on the right:
fig, axs = plt.subplot_mosaic([['left', 'right_top'],
                               ['left', 'right_bottom']])

subplots() und subplot_mosaic sind Komfortfunktionen, die zusätzlich Axes-Objekte innerhalb der Figure erstellen, aber Sie können auch später manuell Axes hinzufügen.

Weitere Informationen zu Figures, einschließlich Schwenken und Zoomen, finden Sie unter Einführung in Figures.

Axes

Eine Axes ist ein Artist, der einer Figure zugeordnet ist und einen Bereich zum Zeichnen von Daten enthält. Sie umfasst normalerweise zwei (oder drei im Falle von 3D) Axis-Objekte (beachten Sie den Unterschied zwischen **Axes** und **Axis**), die Ticks und Tick-Beschriftungen bereitstellen, um Skalen für die Daten in der Axes zu liefern. Jede Axes hat auch einen Titel (gesetzt mit set_title()), eine x-Achsenbeschriftung (gesetzt mit set_xlabel()) und eine y-Achsenbeschriftung (gesetzt mit set_ylabel()).

Die Methoden der Axes sind die primäre Schnittstelle zur Konfiguration der meisten Teile Ihres Diagramms (Hinzufügen von Daten, Steuern von Achsenskalen und -grenzen, Hinzufügen von Beschriftungen usw.).

Axis

Diese Objekte legen die Skala und die Grenzen fest und generieren Ticks (die Markierungen auf der Achse) und Tick-Beschriftungen (Zeichenketten, die die Ticks beschriften). Die Position der Ticks wird durch ein Locator-Objekt bestimmt und die Tick-Beschriftungs-Zeichenketten werden von einem Formatter formatiert. Die Kombination aus dem richtigen Locator und Formatter ermöglicht eine sehr feine Kontrolle über die Positionen und Beschriftungen der Ticks.

Artist

Grundsätzlich ist alles Sichtbare auf der Figure ein Artist (sogar Figure, Axes und Axis Objekte). Dazu gehören Text-Objekte, Line2D-Objekte, collections-Objekte, Patch-Objekte usw. Wenn die Figure gerendert wird, werden alle Artists auf die **Leinwand** gezeichnet. Die meisten Artists sind an eine Axes gebunden; ein solcher Artist kann nicht von mehreren Axes gemeinsam genutzt oder von einer zu einer anderen verschoben werden.

Arten von Eingaben für Plot-Funktionen

Plot-Funktionen erwarten numpy.array oder numpy.ma.masked_array als Eingabe oder Objekte, die an numpy.asarray übergeben werden können. Klassen, die Arrays ähnlich sind ("array-ähnlich"), wie z. B. pandas-Datenobjekte und numpy.matrix, funktionieren möglicherweise nicht wie erwartet. Die gängige Konvention ist, diese vor dem Plotten in numpy.array-Objekte umzuwandeln. Zum Beispiel, um eine numpy.matrix umzuwandeln

b = np.matrix([[1, 2], [3, 4]])
b_asarray = np.asarray(b)

Die meisten Methoden parsen auch ein zeichenkettenindizierbares Objekt wie ein *Dict*, ein strukturiertes NumPy-Array oder einen pandas.DataFrame. Matplotlib erlaubt es Ihnen, das data-Schlüsselwortargument bereitzustellen und Diagramme zu generieren, indem Sie die Zeichenketten übergeben, die den x- und y-Variablen entsprechen.

np.random.seed(19680801)  # seed the random number generator.
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

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.scatter('a', 'b', c='c', s='d', data=data)
ax.set_xlabel('entry a')
ax.set_ylabel('entry b')

Coding-Stile

Die expliziten und die impliziten Schnittstellen

Wie oben erwähnt, gibt es im Wesentlichen zwei Möglichkeiten, Matplotlib zu verwenden

• Erstellen Sie explizit Figures und Axes und rufen Sie Methoden darauf auf (der "objektorientierte (OO) Stil").

• Verlassen Sie sich darauf, dass pyplot Figures und Axes implizit erstellt und verwaltet, und verwenden Sie pyplot-Funktionen zum Plotten.

Sehen Sie Matplotlib Application Interfaces (APIs) für eine Erklärung der Kompromisse zwischen den impliziten und expliziten Schnittstellen.

Man kann also den OO-Stil verwenden

x = np.linspace(0, 2, 100)  # Sample data.

# Note that even in the OO-style, we use `.pyplot.figure` to create the Figure.
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.plot(x, x, label='linear')  # Plot some data on the Axes.
ax.plot(x, x**2, label='quadratic')  # Plot more data on the Axes...
ax.plot(x, x**3, label='cubic')  # ... and some more.
ax.set_xlabel('x label')  # Add an x-label to the Axes.
ax.set_ylabel('y label')  # Add a y-label to the Axes.
ax.set_title("Simple Plot")  # Add a title to the Axes.
ax.legend()  # Add a legend.

oder den pyplot-Stil

x = np.linspace(0, 2, 100)  # Sample data.

plt.figure(figsize=(5, 2.7), layout='constrained')
plt.plot(x, x, label='linear')  # Plot some data on the (implicit) Axes.
plt.plot(x, x**2, label='quadratic')  # etc.
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend()

(Zusätzlich gibt es einen dritten Ansatz für den Fall, dass Matplotlib in eine GUI-Anwendung eingebettet wird, der pyplot vollständig fallen lässt, selbst für die Figurenerstellung. Siehe den entsprechenden Abschnitt in der Galerie für weitere Informationen: Einbetten von Matplotlib in grafische Benutzeroberflächen.)

Matplotlibs Dokumentation und Beispiele verwenden sowohl den OO- als auch den pyplot-Stil. Im Allgemeinen empfehlen wir die Verwendung des OO-Stils, insbesondere für komplizierte Diagramme und Funktionen und Skripte, die als Teil eines größeren Projekts wiederverwendet werden sollen. Der pyplot-Stil kann jedoch für schnelle interaktive Arbeiten sehr praktisch sein.

Hinweis

Sie finden möglicherweise ältere Beispiele, die die pylab-Schnittstelle verwenden, über from pylab import *. Dieser Ansatz ist stark veraltet.

Erstellen von Hilfsfunktionen

Wenn Sie immer wieder dieselben Diagramme mit unterschiedlichen Datensätzen erstellen müssen oder Matplotlib-Methoden einfach kapseln möchten, verwenden Sie die unten empfohlene Signaturfunktion.

def my_plotter(ax, data1, data2, param_dict):
    """
    A helper function to make a graph.
    """
    out = ax.plot(data1, data2, **param_dict)
    return out

die Sie dann zweimal verwenden würden, um zwei Unterdiagramme zu füllen

data1, data2, data3, data4 = np.random.randn(4, 100)  # make 4 random data sets
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(5, 2.7))
my_plotter(ax1, data1, data2, {'marker': 'x'})
my_plotter(ax2, data3, data4, {'marker': 'o'})

Beachten Sie, dass Sie, wenn Sie diese als Python-Paket oder andere Anpassungen installieren möchten, eine der vielen Vorlagen im Web verwenden könnten; Matplotlib hat eine unter mpl-cookiecutter

Styling von Artists

Die meisten Plotting-Methoden verfügen über Styling-Optionen für die Artists, die entweder beim Aufruf einer Plotting-Methode oder über einen "Setter" des Artists zugänglich sind. Im folgenden Diagramm setzen wir manuell die *Farbe*, *Linienbreite* und den *Linienstil* der von plot erstellten Artists und setzen den Linienstil der zweiten Linie nachträglich mit set_linestyle.

fig, ax = plt.subplots(figsize=(5, 2.7))
x = np.arange(len(data1))
ax.plot(x, np.cumsum(data1), color='blue', linewidth=3, linestyle='--')
l, = ax.plot(x, np.cumsum(data2), color='orange', linewidth=2)
l.set_linestyle(':')

Farben

Matplotlib verfügt über eine sehr flexible Palette von Farben, die für die meisten Artists akzeptiert werden; siehe zulässige Farbdefinitionen für eine Liste der Spezifikationen. Einige Artists nehmen mehrere Farben an. z. B. für ein scatter-Diagramm können die Ränder der Markierungen andere Farben als das Innere haben

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.scatter(data1, data2, s=50, facecolor='C0', edgecolor='k')

Linienbreiten, Linienstile und Markergrößen

Linienbreiten sind typischerweise in typografischen Punkten (1 pt = 1/72 Zoll) angegeben und für Artists verfügbar, die gestrichene Linien haben. Ebenso können gestrichene Linien einen Linienstil haben. Sehen Sie sich das Beispiel für Linienstile an.

Die Markergröße hängt von der verwendeten Methode ab. plot gibt die Markergröße in Punkten an und ist im Allgemeinen der "Durchmesser" oder die Breite des Markers. scatter gibt die Markergröße als annähernd proportional zur visuellen Fläche des Markers an. Es gibt eine Reihe von Marker-Stilen, die als Zeichencodes verfügbar sind (siehe markers), oder Benutzer können ihre eigenen MarkerStyle definieren (siehe Marker-Referenz)

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(data1, 'o', label='data1')
ax.plot(data2, 'd', label='data2')
ax.plot(data3, 'v', label='data3')
ax.plot(data4, 's', label='data4')
ax.legend()

Beschriftung von Diagrammen

Achsenbeschriftungen und Text

set_xlabel, set_ylabel und set_title werden verwendet, um Text an den angegebenen Positionen hinzuzufügen (siehe Text in Matplotlib für weitere Diskussionen). Text kann auch direkt zu Diagrammen mit text hinzugefügt werden

mu, sigma = 115, 15
x = mu + sigma * np.random.randn(10000)
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
# the histogram of the data
n, bins, patches = ax.hist(x, 50, density=True, facecolor='C0', alpha=0.75)

ax.set_xlabel('Length [cm]')
ax.set_ylabel('Probability')
ax.set_title('Aardvark lengths\n (not really)')
ax.text(75, .025, r'$\mu=115,\ \sigma=15$')
ax.axis([55, 175, 0, 0.03])
ax.grid(True)

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

t = ax.set_xlabel('my data', fontsize=14, color='red')

Diese Eigenschaften werden in Text-Eigenschaften und Layout ausführlicher behandelt.

Verwendung mathematischer Ausdrücke 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

ax.set_title(r'$\sigma_i=15$')

wobei das r vor der Titelzeichenkette bedeutet, dass die Zeichenkette eine *Rohzeichenkette* ist und Backslashes nicht als Python-Escapes behandelt werden sollen. Matplotlib verfügt über eine integrierte TeX-Ausdrucksparser- und Layout-Engine und liefert eigene mathematische Schriftarten – Details finden Sie unter Mathematische Ausdrücke schreiben. Sie können auch LaTeX direkt verwenden, um Ihren Text zu formatieren und die Ausgabe direkt in Ihre angezeigten Figuren oder gespeichsten Postscript-Dateien einzufügen – siehe Textrendering mit LaTeX.

Annotationen

Wir können auch Punkte in einem Diagramm annotieren, oft indem wir einen Pfeil auf *xy* zeigen lassen, zu einem Text bei *xytext*

fig, ax = plt.subplots(figsize=(5, 2.7))

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

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

ax.set_ylim(-2, 2)

In diesem einfachen Beispiel befinden sich sowohl *xy* als auch *xytext* in Datenkoordinaten. Es gibt eine Vielzahl anderer Koordinatensysteme, aus denen man wählen kann – siehe Grundlegende Annotation und Erweiterte Annotation für Details. Weitere Beispiele finden Sie auch unter Diagramme annotieren.

Legenden

Oft möchten wir Linien oder Markierungen mit einer Axes.legend identifizieren

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(np.arange(len(data1)), data1, label='data1')
ax.plot(np.arange(len(data2)), data2, label='data2')
ax.plot(np.arange(len(data3)), data3, 'd', label='data3')
ax.legend()

Legenden in Matplotlib sind in Bezug auf Layout, Platzierung und welche Artists sie darstellen können, sehr flexibel. Sie werden ausführlich in Legend-Leitfaden besprochen.

Achsenskalen und Ticks

Jede Axes hat zwei (oder drei) Axis-Objekte, die die x- und y-Achse darstellen. Diese steuern die *Skala* der Achse, die Tick-*Locator* und die Tick-*Formatter*. Zusätzliche Axes können angefügt werden, um weitere Axis-Objekte anzuzeigen.

Skalen

Zusätzlich zur linearen Skala bietet Matplotlib nichtlineare Skalen, wie z. B. eine logarithmische Skala. Da logarithmische Skalen so häufig verwendet werden, gibt es auch direkte Methoden wie loglog, semilogx und semilogy. Es gibt eine Reihe von Skalen (siehe Übersicht über Skalen für weitere Beispiele). Hier setzen wir die Skala manuell

fig, axs = plt.subplots(1, 2, figsize=(5, 2.7), layout='constrained')
xdata = np.arange(len(data1))  # make an ordinal for this
data = 10**data1
axs[0].plot(xdata, data)

axs[1].set_yscale('log')
axs[1].plot(xdata, data)

Die Skala legt die Abbildung von Datenwerten auf den Abstand entlang der Achse fest. Dies geschieht in beiden Richtungen und wird zu einer *Transformation* kombiniert, was die Art und Weise ist, wie Matplotlib von Datenkoordinaten zu Axes-, Figure- oder Bildschirmkoordinaten abbildet. Siehe Transformations-Tutorial.

Tick-Locator und Formatter

Jede Achse hat einen Tick-*Locator* und -*Formatter*, die entscheiden, wo entlang der Achsenobjekte Tick-Markierungen platziert werden. Eine einfache Schnittstelle hierzu ist set_xticks

fig, axs = plt.subplots(2, 1, layout='constrained')
axs[0].plot(xdata, data1)
axs[0].set_title('Automatic ticks')

axs[1].plot(xdata, data1)
axs[1].set_xticks(np.arange(0, 100, 30), ['zero', '30', 'sixty', '90'])
axs[1].set_yticks([-1.5, 0, 1.5])  # note that we don't need to specify labels
axs[1].set_title('Manual ticks')

Unterschiedliche Skalen können unterschiedliche Locator und Formatter haben; zum Beispiel verwendet die obige logarithmische Skala LogLocator und LogFormatter. Sehen Sie sich Tick-Locator und Tick-Formatter für andere Formatter und Locator sowie Informationen zum Schreiben eigener an.

Plotting von Daten und Zeichenketten

Matplotlib kann Arrays von Daten und Arrays von Zeichenketten sowie Gleitkommazahlen verarbeiten. Diese erhalten spezielle Locator und Formatter nach Bedarf. Für Daten

from matplotlib.dates import ConciseDateFormatter

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
dates = np.arange(np.datetime64('2021-11-15'), np.datetime64('2021-12-25'),
                  np.timedelta64(1, 'h'))
data = np.cumsum(np.random.randn(len(dates)))
ax.plot(dates, data)
ax.xaxis.set_major_formatter(ConciseDateFormatter(ax.xaxis.get_major_locator()))

Weitere Informationen finden Sie in den Datumsbeispielen (z. B. Datums-Tick-Beschriftungen)

Für Zeichenketten erhalten wir kategoriale Diagramme (siehe: Plotting von kategorialen Variablen).

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
categories = ['turnips', 'rutabaga', 'cucumber', 'pumpkins']

ax.bar(categories, np.random.rand(len(categories)))

Eine Einschränkung bei kategorialen Diagrammen ist, dass einige Methoden zum Parsen von Textdateien eine Liste von Zeichenketten zurückgeben, auch wenn die Zeichenketten alle Zahlen oder Daten darstellen. Wenn Sie 1000 Zeichenketten übergeben, wird Matplotlib denken, dass Sie 1000 Kategorien meinten, und wird 1000 Ticks zu Ihrem Diagramm hinzufügen!

Zusätzliche Axes-Objekte

Das Plotten von Daten mit unterschiedlicher Größenordnung in einem Diagramm erfordert möglicherweise eine zusätzliche y-Achse. Eine solche Achse kann durch die Verwendung von twinx erstellt werden, um eine neue Axes mit einer unsichtbaren x-Achse und einer y-Achse auf der rechten Seite hinzuzufügen (analog für twiny). Sehen Sie sich Diagramme mit unterschiedlichen Skalen für ein weiteres Beispiel an.

Ebenso können Sie eine secondary_xaxis oder secondary_yaxis hinzufügen, die eine andere Skala als die Hauptachse haben, um die Daten in unterschiedlichen Skalen oder Einheiten darzustellen. Sehen Sie sich Sekundäre Achse für weitere Beispiele an.

fig, (ax1, ax3) = plt.subplots(1, 2, figsize=(7, 2.7), layout='constrained')
l1, = ax1.plot(t, s)
ax2 = ax1.twinx()
l2, = ax2.plot(t, range(len(t)), 'C1')
ax2.legend([l1, l2], ['Sine (left)', 'Straight (right)'])

ax3.plot(t, s)
ax3.set_xlabel('Angle [rad]')
ax4 = ax3.secondary_xaxis('top', (np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')

Farbkodierte Daten

Oft möchten wir eine dritte Dimension in einem Diagramm darstellen, die durch Farben in einer Colormap repräsentiert wird. Matplotlib hat eine Reihe von Diagrammtypen, die dies tun

from matplotlib.colors import LogNorm

X, Y = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))
Z = (1 - X/2 + X**5 + Y**3) * np.exp(-X**2 - Y**2)

fig, axs = plt.subplots(2, 2, layout='constrained')
pc = axs[0, 0].pcolormesh(X, Y, Z, vmin=-1, vmax=1, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[0, 0])
axs[0, 0].set_title('pcolormesh()')

co = axs[0, 1].contourf(X, Y, Z, levels=np.linspace(-1.25, 1.25, 11))
fig.colorbar(co, ax=axs[0, 1])
axs[0, 1].set_title('contourf()')

pc = axs[1, 0].imshow(Z**2 * 100, cmap='plasma', norm=LogNorm(vmin=0.01, vmax=100))
fig.colorbar(pc, ax=axs[1, 0], extend='both')
axs[1, 0].set_title('imshow() with LogNorm()')

pc = axs[1, 1].scatter(data1, data2, c=data3, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[1, 1], extend='both')
axs[1, 1].set_title('scatter()')

Colormaps

Dies sind alles Beispiele für Artists, die von ScalarMappable-Objekten abgeleitet sind. Sie alle können eine lineare Abbildung zwischen *vmin* und *vmax* in die durch *cmap* angegebene Colormap einstellen. Matplotlib hat viele Colormaps zur Auswahl (Auswahl von Colormaps in Matplotlib), Sie können Ihre eigenen erstellen (Erstellung von Colormaps in Matplotlib) oder als Drittanbieterpakete herunterladen.

Normalisierungen

Manchmal möchten wir eine nichtlineare Abbildung der Daten auf die Colormap, wie im obigen LogNorm-Beispiel. Dies tun wir, indem wir der ScalarMappable das Argument *norm* anstelle von *vmin* und *vmax* übergeben. Weitere Normalisierungen finden Sie unter Colormap-Normalisierung.

Farbbalken

Das Hinzufügen eines colorbar liefert einen Schlüssel, um die Farbe zurück zu den zugrunde liegenden Daten zu verknüpfen. Farbbalken sind Figure-Level-Artists und werden an eine ScalarMappable angehängt (wo sie ihre Informationen über Norm und Colormap erhalten) und stehlen normalerweise Platz von einer übergeordneten Axes. Die Platzierung von Farbbalken kann komplex sein: Einzelheiten finden Sie unter Platzierung von Farbbalken. Sie können auch das Aussehen von Farbbalken mit dem Schlüsselwort *extend* ändern, um Pfeile an den Enden hinzuzufügen, und *shrink* und *aspect*, um die Größe zu steuern. Schließlich hat der Farbbalken standardmäßig Locator und Formatter, die für die Norm geeignet sind. Diese können wie bei anderen Achsenobjekten geändert werden.

Arbeiten mit mehreren Figures und Axes

Sie können mehrere Figures mit mehreren Aufrufen von fig = plt.figure() oder fig2, ax = plt.subplots() öffnen. Durch Beibehaltung der Objektverweise können Sie Artists zu beiden Figures hinzufügen.

Mehrere Axes können auf verschiedene Arten hinzugefügt werden, aber die grundlegendste ist plt.subplots(), wie oben verwendet. Komplexere Layouts mit Axes-Objekten, die Spalten oder Zeilen überspannen, können mit subplot_mosaic erreicht werden.

fig, axd = plt.subplot_mosaic([['upleft', 'right'],
                               ['lowleft', 'right']], layout='constrained')
axd['upleft'].set_title('upleft')
axd['lowleft'].set_title('lowleft')
axd['right'].set_title('right')

Matplotlib verfügt über recht ausgefeilte Werkzeuge zur Anordnung von Achsen: Siehe Arranging multiple Axes in a Figure und Complex and semantic figure composition (subplot_mosaic).

Weitere Lektüre

Weitere Plot-Typen finden Sie unter Plot types und in der API reference, insbesondere in der Axes API.