Kurzanleitung

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

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

Ein einfaches Beispiel

Matplotlib stellt Ihre Daten in Figures (z. B. Fenstern, Jupyter-Widgets usw.) grafisch dar, von denen jedes ein oder mehrere enthalten kann Axes, einen Bereich, in dem Punkte in Form von xy-Koordinaten (oder theta-r in einem Polardiagramm, xyz in einem 3D-Diagramm usw.). Der einfachste Weg, eine Figur mit Achsen zu erstellen, ist die Verwendung von pyplot.subplots. Wir können dann verwenden Axes.plot, um einige Daten auf den Achsen zu zeichnen:

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.

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

Teile einer Figur

Hier sind die Komponenten einer Matplotlib-Figur.

Figure

Die ganze Figur. Die Figur verfolgt alle Kinder Axes, eine Gruppe „spezieller“ Künstler (Titel, Figurenlegenden, Farbbalken usw.) und sogar verschachtelte Unterfiguren.

Der einfachste Weg, eine neue Figur zu erstellen, ist mit pyplot:

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

Es ist oft praktisch, die Achsen zusammen mit der Figur zu erstellen, aber Sie können Achsen auch später manuell hinzufügen. Beachten Sie, dass viele Matplotlib-Backends das Zoomen und Schwenken von Abbildungsfenstern unterstützen.

Axes

Ein Axes ist ein Artist, der an eine Figur angehängt ist, die einen Bereich zum Zeichnen von Daten enthält und normalerweise zwei (oder drei im Fall von 3D) AxisObjekte enthält (beachten Sie den Unterschied zwischen Axes und Axis ), die Ticks und Tick-Beschriftungen bereitstellen Skalen für die Daten in den Achsen. Jedes Axeshat auch einen Titel (eingestellt über set_title()), ein x-Label (eingestellt über set_xlabel()) und ein y-Label (eingestellt über set_ylabel()).

Die AxesKlasse und ihre Mitgliedsfunktionen sind der primäre Einstiegspunkt für die Arbeit mit der OOP-Schnittstelle und haben die meisten Plotmethoden darauf definiert (z . B. ax.plot()verwendet die oben gezeigte Methode die plotMethode) .

Axis

Diese Objekte legen die Skalierung und die Grenzen fest und erzeugen Ticks (die Markierungen auf der Achse) und Ticklabels (Strings, die die Ticks beschriften). Die Position der Ticks wird durch ein LocatorObjekt bestimmt und die Ticklabel-Strings werden durch ein formatiert Formatter. Die Kombination aus richtig Locatorund Formattergibt eine sehr feine Kontrolle über die Tick-Positionen und Beschriftungen.

Artist

Grundsätzlich ist alles, was auf der Figur sichtbar ist, ein Künstler (sogar Figure, Axes, und AxisObjekte). Dazu gehören TextObjekte, Line2DObjekte, collectionsObjekte, Patch Objekte usw. Wenn die Figur gerendert wird, werden alle Künstler auf die Leinwand gezogen . Die meisten Künstler sind an eine Axt gebunden; Ein solcher Künstler kann nicht von mehreren Achsen geteilt oder von einer Achse zur anderen verschoben werden.

Arten von Eingaben für Plotfunktionen

Zeichenfunktionen erwarten numpy.arrayoder numpy.ma.masked_arrayals Eingabe oder Objekte, die an übergeben werden können numpy.asarray. Klassen, die Arrays ähnlich sind („array-like“), wie z. B. pandas Datenobjekte, numpy.matrixfunktionieren möglicherweise nicht wie vorgesehen. numpy.arrayÜbliche Konvention ist es, diese vor dem Plotten in Objekte umzuwandeln . Um zum Beispiel a umzuwandelnnumpy.matrix

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

Die meisten Methoden parsen auch ein adressierbares Objekt wie ein dict , a numpy.recarrayoder a pandas.DataFrame. Mit Matplotlib können Sie das dataSchlüsselwortargument bereitstellen und Diagramme erstellen, die die Zeichenfolgen ü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');

Text(36.334, 0.5, 'entry b')

Codierungsstile

Die expliziten und die impliziten Schnittstellen

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

• Erstellen Sie explizit Figuren und Achsen und rufen Sie Methoden für sie auf (der "objektorientierte (OO) Stil").

• Verlassen Sie sich auf pyplot, um die Figuren und Achsen implizit zu erstellen und zu verwalten, und verwenden Sie pyplot-Funktionen zum Plotten.

Siehe Matplotlib-Anwendungsschnittstellen (APIs) für eine Erläuterung 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.

<matplotlib.legend.Legend object at 0x7f2cdf587f70>

oder im 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();

<matplotlib.legend.Legend object at 0x7f2cfa992cb0>

(Zusätzlich gibt es einen dritten Ansatz, für den Fall, dass Matplotlib in eine GUI-Anwendung eingebettet wird, die Pyplot vollständig fallen lässt, sogar für die Abbildungserstellung. Weitere Informationen finden Sie im entsprechenden Abschnitt in der Galerie: Matplotlib in grafische Benutzeroberflächen einbetten .)

Die Dokumentation und Beispiele von Matplotlib verwenden sowohl den OO- als auch den Pyplot-Stil. Im Allgemeinen empfehlen wir die Verwendung des OO-Stils, insbesondere für komplizierte Plots und Funktionen und Skripte, die als Teil eines größeren Projekts wiederverwendet werden sollen. Der Pyplot-Stil kann jedoch für schnelles interaktives Arbeiten sehr praktisch sein.

Notiz

Möglicherweise finden Sie ältere Beispiele, die die pylabSchnittstelle verwenden, über . Dieser Ansatz wird stark abgelehnt.from pylab import *

Hilfsfunktionen erstellen

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

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 Subplots 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'});

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

Beachten Sie, dass Sie, wenn Sie diese als Python-Paket oder andere Anpassungen installieren möchten, eine der vielen Vorlagen im Internet verwenden können. Matplotlib hat einen bei mpl-cookiecutter

Styling-Künstler

Die meisten Plotmethoden haben Gestaltungsoptionen für die Künstler, auf die entweder zugegriffen werden kann, wenn eine Plotmethode aufgerufen wird, oder von einem "Setter" auf dem Künstler. Im Diagramm unten stellen wir manuell die Farbe , Linienstärke und den Linienstil der Künstler ein, die von erstellt wurden plot, und wir stellen den Linienstil der zweiten Linie nachträglich mit ein 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 hat eine sehr flexible Farbpalette, die von den meisten Künstlern akzeptiert wird; Eine Liste der Spezifikationen finden Sie im Farbtutorial . Einige Künstler nehmen mehrere Farben. d.h. bei einem scatterGrundstück kann der Rand 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');

<matplotlib.collections.PathCollection object at 0x7f2cddcf8280>

Linienbreiten, Linienstile und Markierungsgrößen

Linienbreiten werden normalerweise in typografischen Punkten (1 pt = 1/72 Zoll) angegeben und sind für Künstler verfügbar, die Strichlinien haben. Ebenso können Strichlinien einen Linienstil haben. Sehen Sie sich das Linienstil-Beispiel an .

Die Markergröße hängt von der verwendeten Methode ab. plotgibt die Markergröße in Punkten an und ist im Allgemeinen der "Durchmesser" oder die Breite des Markers. scattergibt die Markergröße ungefähr proportional zum sichtbaren Bereich des Markers an. Es gibt eine Reihe von Markierungsstilen, die als Zeichenfolgencodes verfügbar sind (siehe markers), oder Benutzer können ihre eigenen definieren MarkerStyle(siehe Markierungsreferenz ):

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();

<matplotlib.legend.Legend object at 0x7f2cfa946650>

Plots beschriften

Achsenbeschriftungen und Text

set_xlabel, set_ylabel, und set_titlewerden verwendet, um Text an den angegebenen Stellen hinzuzufügen ( weitere Erläuterungen finden Sie unter Text in Matplotlib-Plots ). Text kann auch direkt zu Plots hinzugefügt werden mit text:

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 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:

t = ax.set_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:

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

wobei das rVoranstellen der Titelzeichenfolge bedeutet, dass die Zeichenfolge eine Rohzeichenfolge ist und Backslashes nicht als Python-Escapes behandelt werden sollen. Matplotlib verfügt über einen integrierten TeX-Ausdrucksparser und eine Layout-Engine und liefert eigene mathematische Schriftarten aus – für Details siehe Mathematische Ausdrücke schreiben . Sie können LaTeX auch direkt verwenden, um Ihren Text zu formatieren und die Ausgabe direkt in Ihre Anzeigeabbildungen oder gespeichertes Postscript einzubinden – siehe Textdarstellung mit LaTeX .

Anmerkungen

Wir können auch Punkte auf einem Diagramm kommentieren, oft indem wir einen Pfeil, der auf xy zeigt, mit einem Textstück bei xytext verbinden :

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);

(-2.0, 2.0)

In diesem einfachen Beispiel sind sowohl xy als auch xytext 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 auch unter Diagramme kommentieren .

Legenden

Oft möchten wir Linien oder Markierungen mit einem Axes.legend:

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();

<matplotlib.legend.Legend object at 0x7f2cde2aaa40>

Legenden in Matplotlib sind ziemlich flexibel in Bezug auf Layout, Platzierung und welche Künstler sie darstellen können. Sie werden im Legend Guide ausführlich besprochen .

Achsenskalen und Ticks

Jede Achse hat zwei (oder drei) AxisObjekte, die die x- und y-Achse darstellen. Diese steuern die Skalierung der Achse, die Tick - Lokatoren und die Tick - Formatierer . Zusätzliche Achsen können hinzugefügt werden, um weitere Achsenobjekte anzuzeigen.

Waage

Zusätzlich zur linearen Skala liefert Matplotlib nichtlineare Skalen, wie z. B. eine logarithmische Skala. Da Log-Skalen so häufig verwendet werden, gibt es auch direkte Methoden wie loglog, semilogx, und semilogy. Es gibt eine Reihe von Skalen ( weitere Beispiele finden Sie unter Skalen) . Hier stellen wir die Skalierung manuell ein:

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);

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

Die Skala legt die Zuordnung von Datenwerten zu Abständen entlang der Achse fest. Dies geschieht in beide Richtungen und wird zu einer Transformation kombiniert , so dass Matplotlib Datenkoordinaten auf Axes-, Figure- oder Bildschirmkoordinaten abbildet. Siehe Lernprogramm für Transformationen .

Tick-Locators und Formatierer

Jede Achse verfügt über einen Tick - Locator und einen Formatierer , die auswählen, wo entlang der Achsenobjekte Tick-Markierungen gesetzt werden sollen. Eine einfache Schnittstelle dazu 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');

Text(0.5, 1.0, 'Manual ticks')

Unterschiedliche Skalen können unterschiedliche Locators und Formatierer haben; Zum Beispiel verwendet die obige Log-Skala LogLocatorund LogFormatter. Siehe Tick Locators und Tick Formatters für andere Formatierer und Locators und Informationen zum Schreiben eigener.

Daten und Zeichenfolgen zeichnen

Matplotlib kann das Zeichnen von Arrays von Datumsangaben und Arrays von Zeichenfolgen sowie von Gleitkommazahlen handhaben. Diese erhalten gegebenenfalls spezielle Lokalisierer und Formatierer. Für Termine:

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)
cdf = mpl.dates.ConciseDateFormatter(ax.xaxis.get_major_locator())
ax.xaxis.set_major_formatter(cdf);

Weitere Informationen finden Sie in den Datumsbeispielen (z. B. Datumsmarkierungen )

Für Strings erhalten wir kategoriales Plotten (siehe: Kategoriale Variablen plotten ).

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

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

<BarContainer object of 4 artists>

Eine Einschränkung beim kategorialen Plotten ist, dass einige Methoden zum Analysieren von Textdateien eine Liste von Zeichenfolgen zurückgeben, selbst wenn die Zeichenfolgen alle Zahlen oder Daten darstellen. Wenn Sie 1000 Zeichenfolgen übergeben, denkt Matplotlib, dass Sie 1000 Kategorien gemeint haben, und fügt Ihrem Diagramm 1000 Ticks hinzu!

Zusätzliche Achsenobjekte

Das Darstellen von Daten unterschiedlicher Größe in einem Diagramm erfordert möglicherweise eine zusätzliche y-Achse. Eine solche Achse kann erstellt werden, indem mit twinxeine neue Achse mit unsichtbarer x-Achse und rechts positionierter y-Achse hinzugefügt wird (analog zu twiny). Ein weiteres Beispiel finden Sie unter Diagramme mit unterschiedlichen Maßstäben .

Auf ähnliche Weise können Sie eine secondary_xaxisoder secondary_yaxismit einer anderen Skala als die Hauptachse hinzufügen, um die Daten in anderen Skalen oder Einheiten darzustellen. Weitere Beispiele finden Sie unter Sekundärachse .

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', functions=(np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')

Text(0.5, 509.6660000000001, 'Angle [°]')

Farblich gemappte Daten

Oft möchten wir eine dritte Dimension in einem Diagramm haben, das durch Farben in einer Farbkarte dargestellt wird. Matplotlib hat eine Reihe von Diagrammtypen, die dies tun:

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=mpl.colors.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()')

Text(0.5, 1.0, 'scatter()')

Farbkarten

Dies sind alles Beispiele für Künstler, die von ScalarMappable Objekten abgeleitet sind. Sie alle können eine lineare Zuordnung zwischen vmin und vmax in die durch cmap angegebene Farbtabelle setzen . Matplotlib hat viele Colormaps zur Auswahl ( Choosing Colormaps in Matplotlib ), Sie können Ihre eigenen erstellen ( Creating Colormaps in Matplotlib ) oder als Pakete von Drittanbietern herunterladen .

Normalisierungen

Manchmal möchten wir eine nichtlineare Abbildung der Daten auf die Farbtabelle, wie im LogNormobigen Beispiel. Wir tun dies, indem wir das ScalarMappable mit dem Normargument anstelle von vmin und vmax versorgen . Weitere Normalisierungen werden unter Colormap Normalization angezeigt .

Farbbalken

Das Hinzufügen von a colorbargibt einen Schlüssel, um die Farbe wieder mit den zugrunde liegenden Daten in Beziehung zu setzen. Colorbars sind Artists auf Figurebene und sind an ScalarMappable angehängt (wo sie ihre Informationen über die Norm und Colormap erhalten) und stehlen normalerweise Platz von übergeordneten Axes. Die Platzierung von Farbbalken kann komplex sein: Einzelheiten finden Sie unter Platzieren von Farbbalken . Sie können das Erscheinungsbild von Farbbalken auch mit dem Schlüsselwort Erweitern ändern , um Pfeile an den Enden hinzuzufügen, und Verkleinern und Ausrichten , um die Größe zu steuern. Schließlich wird der Farbbalken Standard-Locators und -Formatierer haben, die der Norm entsprechen. Diese können wie bei anderen Achsenobjekten geändert werden.

Arbeiten mit mehreren Figuren und Achsen

Sie können mehrere Abbildungen mit mehreren Aufrufen von oder öffnen . Indem Sie die Objektreferenzen beibehalten, können Sie jeder Figur Künstler hinzufügen.fig = plt.figure()fig2, ax = plt.subplots()

Mehrere Achsen können auf verschiedene Arten hinzugefügt werden, aber die grundlegendste ist plt.subplots()die oben beschriebene. Man kann komplexere Layouts erreichen, mit Axes-Objekten, die sich über Spalten oder Zeilen erstrecken, indem man verwendet subplot_mosaic.

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');

Text(0.5, 1.0, 'right')

Matplotlib verfügt über ziemlich ausgefeilte Werkzeuge zum Anordnen von Achsen: Siehe Anordnen mehrerer Achsen in einer Figur und Komplexe und semantische Figurenkomposition .

Mehr lesen

Weitere Diagrammtypen finden Sie unter Diagrammtypen und in der API-Referenz , insbesondere in der Axes -API .