0Pricing
Pandas & NumPy Academy · Lezione

Architettura di Figure e Axes

Comprenda la gerarchia Figure-Axes-Artist, crei grafici con plt.subplots() e distingua le API stateless da quelle object-oriented.

Architettura di Figure e Axes è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Perché imparare l'architettura di Matplotlib?

Pandas e Seaborn usano entrambi Matplotlib internamente. Comprendere la gerarchia degli oggetti di Matplotlib Le consente di controllare ogni aspetto di un grafico, dalla tela complessiva ai singoli segni delle tacche, e di combinare più grafici in un'unica figura. Senza comprendere il modello Figure-Axes, personalizzare i grafici diventa rapidamente un frustrante esercizio per tentativi, in cui si cerca di indovinare quale funzione chiamare.

La Figure: la tela

Una Figure è il contenitore più esterno: l'intera finestra o il file immagine. Contiene uno o più oggetti Axes (le aree effettive del grafico), oltre a un titolo, legende condivise e spazi vuoti. Si crea una Figure con plt.figure() oppure implicitamente tramite plt.subplots(). La maggior parte delle proprietà impostate sulla Figure riguarda l'intera tela: dimensioni, colore di sfondo e titolo generale.

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

Gli Axes: dove vengono creati i grafici

Un oggetto Axes è una singola area del grafico all'interno di una Figure. Contiene l'asse x, l'asse y, i segni delle tacche, le linee della griglia e tutti gli elementi visivi (linee, barre e punti dello scatter plot). La maggior parte delle chiamate di grafico sono metodi di un oggetto Axes: ax.plot(), ax.bar(), ax.scatter(). Una Figure può contenere più Axes, disposti in una griglia di sottografici.

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(): creare insieme Figure e Axes

plt.subplots(nrows, ncols) è il modo consigliato per creare una Figure con uno o più Axes disposti in una griglia. Restituisce una tupla di (fig, ax) (oppure (fig, axes_array) per più sottografici). Il parametro figsize imposta le dimensioni complessive della tela in pollici. Per maggiore chiarezza, assegni sempre il risultato a variabili con nomi esplicativi.

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

API orientata agli oggetti e API con stato

Matplotlib offre due stili di utilizzo. L'API con stato (pyplot) usa plt.plot(), plt.xlabel() e così via, e agisce sugli Axes "correnti": è comoda per una rapida esplorazione interattiva. L'API orientata agli oggetti (OO) chiama esplicitamente i metodi sugli oggetti ax: ax.plot(), ax.set_xlabel(). L'API OO è fortemente consigliata per il codice di produzione e per le figure con più pannelli, perché rende inequivocabile quale asse venga modificato.

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

Gli Artists: i componenti fondamentali

Tutto ciò che è visibile in un grafico Matplotlib è un Artist: la Figure, gli Axes, le linee, il testo, le patch (rettangoli per le barre) e i marker. La gerarchia Figure-Axes-Artist procede dal contenitore più esterno fino all'elemento visivo più piccolo. Comprendere questa gerarchia aiuta a individuare e modificare qualsiasi elemento a livello programmatico, ad esempio cambiando il colore di una barra specifica dopo aver disegnato il grafico.

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

Oggetti Axis: XAxis e YAxis

Ogni Axes contiene due oggetti Axis (da non confondere con Axes): ax.xaxis e ax.yaxis. Questi controllano i tick, le etichette dei tick e lo spine (la linea visibile). È possibile impostare i limiti degli assi con ax.set_xlim() e ax.set_ylim(), controllare la frequenza dei tick con ax.set_xticks() e formattare le etichette con 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()

Assi condivisi per grafici a più pannelli

Quando si crea una griglia di subplot, si passano sharex=True o sharey=True a plt.subplots() per collegare le scale degli assi tra i pannelli. In questo modo, lo zoom o la panoramica su un subplot aggiorna automaticamente tutti i pannelli che condividono quell'asse: è essenziale per confrontare serie temporali di più gruppi quando in ogni pannello deve essere mostrato lo stesso intervallo dell'asse x.

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

Spaziatura con tight_layout()

plt.tight_layout() (o fig.tight_layout()) regola automaticamente i parametri dei subplot per ridurre al minimo la sovrapposizione tra etichette, titoli e tacche. Lo si richiama subito prima di plt.show() o fig.savefig(). Per un controllo più dettagliato, si usa plt.subplots_adjust(hspace=, wspace=) per impostare manualmente lo spazio verticale e orizzontale tra i subplot.

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

Accedere agli Axes da subplots()

Quando plt.subplots(nrows, ncols) restituisce più axes, questi vengono raccolti in un array NumPy con forma (nrows, ncols). È possibile indicizzarli come un normale array bidimensionale: axes[0, 1] indica la prima riga e la seconda colonna. Si usa axes.flat per iterare su tutti gli axes in ordine riga per riga, indipendentemente dalla forma della griglia: è molto comodo per applicare la stessa formattazione a ogni pannello.

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

Rimuovere gli Axes inutilizzati

Quando si crea una griglia di subplot senza utilizzare tutti i pannelli, gli axes vuoti continuano a mostrare i bordi della cornice. Si richiama ax.set_visible(False) oppure fig.delaxes(ax) per nascondere o rimuovere gli axes inutilizzati. Un approccio comune consiste nell'iterare su axes.flat e nascondere tutti i pannelli oltre il numero di serie di dati da visualizzare, mantenendo ordinata la figura.

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

Verifica rapida

Verifichi la Sua comprensione dell'architettura Figure e Axes di Matplotlib presentata in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: la Figure è l'intera area di disegno e l'Axes è una singola area del grafico al suo interno; plt.subplots() crea entrambi e restituisce (fig, ax); l'API object-oriented (ax.plot(), ax.set_xlabel()) è preferibile rispetto all'API pyplot basata sullo stato; infine, tight_layout() evita la sovrapposizione delle etichette nelle figure con più pannelli. Ora creerà grafici a linee e grafici a dispersione con pieno controllo dello stile.

Domande Frequenti

La lezione «Architettura di Figure e Axes» è gratuita?

Sì — il testo completo di «Architettura di Figure e Axes» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Architettura di Figure e Axes»?

Comprenda la gerarchia Figure-Axes-Artist, crei grafici con plt.subplots() e distingua le API stateless da quelle object-oriented. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Architettura di Figure e Axes»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Architettura di Figure e Axes
  2. Grafici a linee e a dispersione
  3. Grafici a barre e istogrammi
  4. Etichette, titoli e salvataggio delle figure
← Torna a Pandas & NumPy Academy