Architektur von Figure und Axes
Verstehen Sie die Hierarchie aus Figure, Axes und Artist, erstellen Sie Diagramme mit plt.subplots() und unterscheiden Sie zustandslose von objektorientierten APIs.
Architektur von Figure und Axes ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum die Matplotlib-Architektur lernen?
Pandas und Seaborn verwenden intern beide Matplotlib. Wenn Sie die Objekthierarchie von Matplotlib verstehen, können Sie jeden Aspekt eines Diagramms steuern – von der gesamten Zeichenfläche bis hin zu einzelnen Teilstrichen – und mehrere Diagramme in einer einzigen Figure kombinieren. Ohne Verständnis des Figure-Axes-Modells wird das Anpassen von Diagrammen schnell zu einem frustrierenden Ratespiel, bei dem Sie herausfinden müssen, welche Funktion aufzurufen ist.
Die Figure: die Zeichenfläche
Eine Figure ist der äußerste Container – das gesamte Fenster oder die gesamte Bilddatei. Sie enthält ein oder mehrere Axes-Objekte (die eigentlichen Diagrammbereiche) sowie einen Titel, gemeinsame Legenden und Leerraum. Sie erstellen eine Figure mit plt.figure() oder implizit über plt.subplots(). Die meisten Eigenschaften, die Sie für die Figure festlegen, wirken sich auf die gesamte Zeichenfläche aus: Größe, Hintergrundfarbe und Gesamttitel.
import matplotlib.pyplot as plt
import numpy as np
# Create a Figure with a specific size
fig = plt.figure(figsize=(8, 4)) # width=8 inches, height=4 inches
print(type(fig)) # matplotlib.figure.Figure
print('Figure size:', fig.get_size_inches())
plt.close() # close to avoid display in scriptsDie Axes: Hier entstehen die Diagramme
Ein Axes-Objekt ist ein einzelner Diagrammbereich innerhalb einer Figure. Es enthält die x-Achse, die y-Achse, Teilstriche, Gitterlinien und alle visuellen Elemente (Linien, Balken und Streupunkte). Die meisten Aufrufe zum Erstellen von Diagrammen sind Methoden eines Axes-Objekts: ax.plot(), ax.bar(), ax.scatter(). Eine Figure kann mehrere Axes enthalten, die als Raster aus Subplots angeordnet sind.
fig, ax = plt.subplots() # Creates Figure + one Axes
print(type(ax)) # matplotlib.axes.Axes
x = np.linspace(0, 10, 100)
ax.plot(x, np.sin(x)) # plot on the Axes
plt.tight_layout()
# plt.show()
plt.close()plt.subplots(): Figure und Axes gemeinsam erstellen
plt.subplots(nrows, ncols) ist die empfohlene Methode, um eine Figure mit einem oder mehreren Axes in einer Rasteranordnung zu erstellen. Die Funktion gibt ein Tupel aus (fig, ax) zurück (oder (fig, axes_array) bei mehreren Subplots). Der Parameter figsize legt die Gesamtgröße der Zeichenfläche in Zoll fest. Packen Sie das Ergebnis für mehr Übersichtlichkeit immer in benannte Variablen aus.
# Single plot
fig, ax = plt.subplots(figsize=(6, 4))
# 2 rows, 1 column
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 8))
# 2 rows, 2 columns
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
ax_top_left = axes[0, 0]
ax_top_right = axes[0, 1]
print('axes shape:', axes.shape) # (2, 2)
plt.close('all')Objektorientierte und zustandsbehaftete API
Matplotlib bietet zwei Nutzungsstile. Die zustandsbehaftete (pyplot-)API verwendet plt.plot(), plt.xlabel() usw. und arbeitet mit den aktuellen Axes – praktisch für die schnelle interaktive Erkundung. Die objektorientierte (OO-)API ruft Methoden explizit für ax-Objekte auf: ax.plot(), ax.set_xlabel(). Für produktiven Code und Abbildungen mit mehreren Teilbereichen wird die OO-API dringend empfohlen, da eindeutig ist, welcher Axes geändert wird.
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]
# Stateful API (convenient but fragile)
# plt.plot(x, y)
# plt.xlabel('x')
# plt.title('Squares')
# Object-oriented API (preferred)
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_xlabel('x')
ax.set_title('Squares')
plt.close()Artists: die Bausteine
Alles, was in einem Matplotlib-Plot sichtbar ist, ist ein Artist: die Figure, Axes, Linien, Texte, Patches (Rechtecke für Balken) und Marker. Die Figure-Axes-Artist-Hierarchie reicht vom äußersten Container bis zum kleinsten visuellen Element. Wenn Sie diese Hierarchie verstehen, können Sie jedes Element programmgesteuert finden und ändern – beispielsweise die Farbe eines bestimmten Balkens, nachdem das Diagramm gezeichnet wurde.
fig, ax = plt.subplots()
line, = ax.plot([1, 2, 3], [1, 4, 9], color='blue', linewidth=2)
# Introspect the hierarchy
print('Figure:', type(fig))
print('Axes:', type(ax))
print('Line Artist:', type(line))
print('Line color:', line.get_color())
plt.close()Axis-Objekte: XAxis und YAxis
Jede Axes enthält zwei Axis-Objekte (nicht zu verwechseln mit Axes): ax.xaxis und ax.yaxis. Diese steuern Ticks, Tick-Beschriftungen und die Spine (die sichtbare Linie). Sie können die Achsengrenzen mit ax.set_xlim() und ax.set_ylim() festlegen, die Tick-Häufigkeit mit ax.set_xticks() steuern und Beschriftungen mit ax.xaxis.set_major_formatter() formatieren.
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [10, 40, 30, 70])
ax.set_xlim(0, 5)
ax.set_ylim(0, 80)
ax.set_xticks([1, 2, 3, 4])
ax.set_xticklabels(['Q1', 'Q2', 'Q3', 'Q4'])
ax.set_xlabel('Quarter')
ax.set_ylabel('Revenue')
plt.close()Gemeinsame Achsen für Diagramme mit mehreren Teilplots
Wenn Sie ein Raster aus Teilplots erstellen, übergeben Sie sharex=True oder sharey=True an plt.subplots(), um die Achsenskalierungen der einzelnen Bereiche zu verknüpfen. Dadurch werden beim Hineinzoomen oder Verschieben in einem Teilplot automatisch alle Teilplots aktualisiert, die diese Achse gemeinsam verwenden – unverzichtbar für den Vergleich von Zeitreihen mehrerer Gruppen, wenn in jedem Teilplot derselbe Bereich der x-Achse angezeigt werden soll.
import numpy as np
x = np.arange(10)
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(6, 5))
ax1.plot(x, x**2, color='blue')
ax1.set_title('Squares')
ax2.plot(x, x**3, color='red')
ax2.set_title('Cubes')
fig.suptitle('Powers of x') # shared figure title
plt.tight_layout()
plt.close()Abstände mit tight_layout()
plt.tight_layout() (oder fig.tight_layout()) passt die Parameter der Teilplots automatisch an, um Überlappungen zwischen Beschriftungen, Titeln und Ticks zu minimieren. Rufen Sie die Funktion direkt vor plt.show() oder fig.savefig() auf. Für eine detaillierte Steuerung verwenden Sie plt.subplots_adjust(hspace=, wspace=), um den vertikalen und horizontalen Abstand zwischen Teilplots manuell festzulegen.
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
for i, ax in enumerate(axes.flat):
ax.plot([1, 2, 3], [i, i+1, i+2])
ax.set_title(f'Panel {i+1}')
ax.set_xlabel('x axis label')
ax.set_ylabel('y axis label')
fig.suptitle('Grid of Plots', y=1.02)
plt.tight_layout() # prevents overlapping labels
plt.close()Auf Axes aus subplots() zugreifen
Wenn plt.subplots(nrows, ncols) mehrere Axes zurückgibt, werden diese in einem NumPy-Array mit der Form (nrows, ncols) verpackt. Greifen Sie darauf wie auf jedes zweidimensionale Array zu: axes[0, 1] bezeichnet die erste Zeile und die zweite Spalte. Verwenden Sie axes.flat, um unabhängig von der Form des Rasters über alle Axes in Zeilenfolge zu iterieren – besonders praktisch, wenn Sie auf jeden Teilplot dieselbe Formatierung anwenden möchten.
fig, axes = plt.subplots(2, 3, figsize=(12, 6))
# Access by row, column
axes[0, 0].set_title('Top Left')
axes[1, 2].set_title('Bottom Right')
# Iterate over all axes
for ax in axes.flat:
ax.set_xlabel('Time')
ax.set_ylabel('Value')
plt.tight_layout()
plt.close()Nicht verwendete Axes entfernen
Wenn Sie ein Raster aus Teilplots erstellen, aber nicht jeden Bereich verwenden, zeigen die leeren Axes weiterhin Rahmen an. Rufen Sie ax.set_visible(False) oder fig.delaxes(ax) auf, um nicht verwendete Axes auszublenden oder zu entfernen. Häufig iteriert man über axes.flat und blendet alle Teilplots aus, die über die Anzahl der dargestellten Datenreihen hinausgehen, damit die Figure übersichtlich bleibt.
fig, axes = plt.subplots(2, 3, figsize=(12, 6))
data_panels = 4 # only 4 plots needed in a 2x3 grid
for i, ax in enumerate(axes.flat):
if i < data_panels:
ax.plot([1, 2, 3], [i, i+1, i+2])
ax.set_title(f'Panel {i+1}')
else:
ax.set_visible(False) # hide extra panels
plt.tight_layout()
plt.close()Kurze Überprüfung
Testen Sie Ihr Verständnis der Figure- und Axes-Architektur von Matplotlib aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Die Figure ist die gesamte Zeichenfläche, während die Axes einen einzelnen Plotbereich darin bezeichnet; plt.subplots() erstellt beide zusammen und gibt (fig, ax) zurück; die objektorientierte API (ax.plot(), ax.set_xlabel()) wird der zustandsbehafteten pyplot-API vorgezogen; und tight_layout() verhindert überlappende Beschriftungen in Figures mit mehreren Teilplots. Als Nächstes erstellen wir Linien- und Streudiagramme mit vollständiger Kontrolle über deren Stil.
Lerne Python mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Architektur von Figure und Axes“ kostenlos?
Ja — der vollständige Text von „Architektur von Figure und Axes“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Architektur von Figure und Axes“?
Verstehen Sie die Hierarchie aus Figure, Axes und Artist, erstellen Sie Diagramme mit plt.subplots() und unterscheiden Sie zustandslose von objektorientierten APIs. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?
Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Architektur von Figure und Axes“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?
Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Architektur von Figure und Axes
- Linien- und Streudiagramme
- Balkendiagramme und Histogramme
- Beschriftungen, Titel und Speichern von Abbildungen