Pandas & NumPy Academy · leksjon

Figur- og aksearkitektur

Forstå hierarkiet Figure–Axes–Artist, opprett figurer med plt.subplots(), og skill mellom det tilstandsløse og det objektorienterte API-et.

Leksjon 1 av 413 trinn

Figur- og aksearkitektur er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hvorfor lære Matplotlib-arkitekturen?

Både Pandas og Seaborn bruker Matplotlib internt. Når De forstår Matplotlibs objekthierarki, kan De kontrollere alle aspekter ved et diagram – fra det overordnede lerretet til individuelle hakemerker – og kombinere flere diagrammer i én figur. Uten å forstå Figure-Axes-modellen blir tilpasning av diagrammer raskt en frustrerende øvelse i å gjette hvilken funksjon som skal kalles.

Figuren: lerretet

En Figure er den ytterste beholderen – hele vinduet eller bildefilen. Den inneholder ett eller flere Axes-objekter (de faktiske diagramområdene), i tillegg til en tittel, delte forklaringer og tomrom. De oppretter en Figure med plt.figure() eller implisitt gjennom plt.subplots(). De fleste egenskaper som angis for Figure, påvirker hele lerretet: størrelse, bakgrunnsfarge og overordnet tittel.

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 scripts

Axes: der diagrammet blir laget

Et Axes-objekt er ett diagramområde i en Figure. Det inneholder x-aksen, y-aksen, hakemerker, rutenettlinjer og alle visuelle elementer (linjer, stolper og spredningspunkter). De fleste diagramkall er metoder på et Axes-objekt: ax.plot(), ax.bar() og ax.scatter(). Én Figure kan inneholde flere Axes, ordnet som et rutenett med underdiagrammer.

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(): Opprette Figure og Axes sammen

plt.subplots(nrows, ncols) er den anbefalte måten å opprette en Figure med ett eller flere Axes i et rutenett. Den returnerer en tuppel med (fig, ax) (eller (fig, axes_array) for flere underdiagrammer). Parameteren figsize angir den samlede størrelsen på lerretet i tommer. Pakk alltid resultatet ut i navngitte variabler for tydelighet.

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

Objektorientert kontra tilstandsbasert API

Matplotlib har to bruksstiler. Det tilstandsbaserte (pyplot-)API-et bruker plt.plot(), plt.xlabel() og så videre, og arbeider på den «aktive» aksen – praktisk for rask interaktiv utforsking. Det objektorienterte (OO-)API-et kaller eksplisitt metoder på ax-objekter: ax.plot(), ax.set_xlabel(). OO-API-et anbefales sterkt for produksjonskode og figurer med flere paneler, fordi det tydelig viser hvilken akse som endres.

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

Alt som er synlig i et Matplotlib-diagram, er en Artist: Figure, Axes, linjer, tekst, figurer (rektangler for stolper) og markører. Figure–Axes–Artist-hierarkiet går fra den ytterste beholderen og ned til det minste visuelle elementet. Når De forstår dette hierarkiet, blir det enklere å finne og endre ethvert element programmatisk – for eksempel å endre fargen på en bestemt stolpe etter at diagrammet er tegnet.

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-objekter: XAxis og YAxis

Hvert Axes inneholder to Axis-objekter (som ikke må forveksles med Axes): ax.xaxis og ax.yaxis. Disse styrer inndelinger, etiketter for inndelinger og akselinjen (den synlige linjen). De kan angi aksegrenser med ax.set_xlim() og ax.set_ylim(), styre hyppigheten av inndelingene med ax.set_xticks() og formatere etiketter med ax.xaxis.set_major_formatter().

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

Delte akser for diagrammer med flere paneler

Når De oppretter et rutenett med underdiagrammer, kan De sende sharex=True eller sharey=True til plt.subplots() for å koble sammen akseskalaene på tvers av panelene. Det betyr at zooming eller panorering i ett underdiagram automatisk oppdaterer alle paneler som deler den aktuelle aksen – noe som er nødvendig når De sammenligner tidsserier for flere grupper der det samme x-akseområdet skal vises i hvert panel.

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

Avstand med tight_layout()

plt.tight_layout() (eller fig.tight_layout()) justerer automatisk parametrene for underdiagrammene for å minimere overlapp mellom etiketter, titler og inndelingsmerker. Kall den rett før plt.show() eller fig.savefig(). For detaljert kontroll kan De bruke plt.subplots_adjust(hspace=, wspace=) til å angi den vertikale og horisontale avstanden mellom underdiagrammene manuelt.

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

Hente Axes fra subplots()

Når plt.subplots(nrows, ncols) returnerer flere akser, pakkes de inn i en NumPy-matrise med formen (nrows, ncols). Indekser dem som De ville indeksert en todimensjonal matrise: axes[0, 1] for første rad og andre kolonne. Bruk axes.flat til å iterere over alle aksene i radvis rekkefølge, uavhengig av rutenettets form – svært praktisk når De vil bruke samme formatering på hvert panel.

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

Fjerne ubrukte akser

Når De oppretter et rutenett med underdiagrammer, men ikke bruker alle panelene, viser de tomme aksene fortsatt ramme kanter. Kall ax.set_visible(False) eller fig.delaxes(ax) for å skjule eller fjerne ubrukte akser. Et vanlig mønster er å iterere over axes.flat og skjule alle paneler etter antallet dataserier De tegner, slik at figuren holder seg ryddig.

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

Kort kontroll

Test forståelsen Deres av Figure- og Axes-arkitekturen i Matplotlib fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at Figure er hele lerretet, mens Axes er ett enkelt diagramområde i det; plt.subplots() oppretter begge samtidig og returnerer (fig, ax); det objektorienterte API-et (ax.plot(), ax.set_xlabel()) foretrekkes fremfor det tilstandsbaserte pyplot-API-et; og tight_layout() hindrer overlappende etiketter i figurer med flere paneler. Deretter skal De opprette linjediagrammer og spredningsdiagrammer med full kontroll over stilen.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Figur- og aksearkitektur» gratis?

Ja – hele teksten i «Figur- og aksearkitektur» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Figur- og aksearkitektur»?

Forstå hierarkiet Figure–Axes–Artist, opprett figurer med plt.subplots(), og skill mellom det tilstandsløse og det objektorienterte API-et. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?

Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Figur- og aksearkitektur»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?

Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Pandas & NumPy Academy