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 scriptsGli 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
- Architettura di Figure e Axes
- Grafici a linee e a dispersione
- Grafici a barre e istogrammi
- Etichette, titoli e salvataggio delle figure