# Python per Data Analytics: Matplotlib, Seaborn e visualizzazione per i colloqui tecnici

> Padroneggiare la visualizzazione dati con Python usando Matplotlib e Seaborn. Tutorial pratico con grafici, stile, subplots e domande frequenti nei colloqui per posizioni di data analytics nel 2026.

- Published: 2026-04-22
- Updated: 2026-04-22
- Author: SharpSkill
- Tags: python, matplotlib, seaborn, data-visualization, data-analytics, interview
- Reading time: 9 min

---

La visualizzazione dei dati con Python rappresenta una delle competenze più frequentemente testate nei colloqui per posizioni di data analytics. I responsabili delle assunzioni si aspettano che i candidati producano grafici chiari e leggibili a partire da dati grezzi — e che sappiano spiegare le proprie scelte progettuali sotto pressione.

Questo tutorial copre Matplotlib 3.10 e Seaborn 0.13, le due librerie che dominano i colloqui tecnici per ruoli di analista e data scientist. Tutti gli esempi di codice funzionano direttamente con Python 3.12+.

> **Consiglio per il colloquio**
>
> La maggior parte dei colloqui di data analytics include una sessione di live coding in cui i candidati devono generare una visualizzazione da un dataset in meno di 15 minuti. I pattern presentati di seguito si applicano direttamente a questi esercizi.

## Configurare un ambiente Python per la visualizzazione dati

Prima di scrivere codice per i grafici, l'ambiente necessita delle dipendenze corrette. Un ambiente virtuale pulito evita conflitti di versione tra Matplotlib, Seaborn e le loro basi comuni NumPy/Pandas.

```bash
# setup.sh
python -m venv venv
source venv/bin/activate
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas numpy
```

Un rapido test di verifica conferma che tutto funziona correttamente:

```python
# verify_install.py
import matplotlib
import seaborn as sns
import pandas as pd

print(f"Matplotlib: {matplotlib.__version__}")
print(f"Seaborn: {sns.__version__}")
print(f"Pandas: {pd.__version__}")
```

Con le dipendenze configurate, il passo successivo si concentra sui fondamenti di Matplotlib — la base di ogni grafico Seaborn.

## Fondamenti di Matplotlib: Figure, Axes e l'API orientata agli oggetti

Matplotlib offre due API: la macchina a stati pyplot e l'interfaccia orientata agli oggetti (OO). L'API OO fornisce controllo esplicito su ogni elemento ed è lo standard atteso nelle codebase professionali e nei colloqui tecnici.

```python
# bar_chart_oo.py
import matplotlib.pyplot as plt
import numpy as np

# Dati di esempio: fatturato trimestrale
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Creare figure e axes esplicitamente
fig, ax = plt.subplots(figsize=(8, 5))

# Disegnare le barre con un colore specifico
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Etichettare gli assi chiaramente — gli intervistatori lo verificano
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Formattare l'asse y con importi in dollari
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Rimuovere i bordi superiore e destro per un aspetto più pulito
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("quarterly_revenue.png", dpi=150)
plt.show()
```

Dettagli chiave che gli intervistatori notano: creazione esplicita di `fig, ax` invece di `plt.plot()`, etichette degli assi leggibili, valori dei tick formattati e rimozione degli elementi grafici superflui (spines non necessari). Queste piccole scelte segnalano un approccio di livello produttivo.

## Costruire subplots per analisi comparative

Nei colloqui viene spesso richiesto di confrontare più metriche fianco a fianco. La funzione `subplots()` gestisce questa esigenza con un layout a griglia.

```python
# subplots_comparison.py
import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
users = [1200, 1350, 1500, 1420, 1680, 1820]
revenue = [24_000, 27_000, 30_000, 28_400, 33_600, 36_400]

# Due grafici affiancati con assi y indipendenti
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Pannello sinistro: crescita utenti come grafico a linee
ax1.plot(months, users, marker="o", color="#2563eb", linewidth=2)
ax1.set_title("Monthly Active Users")
ax1.set_ylabel("Users")
ax1.spines[["top", "right"]].set_visible(False)

# Pannello destro: fatturato come grafico a barre
ax2.bar(months, revenue, color="#16a34a", width=0.5)
ax2.set_title("Monthly Revenue")
ax2.set_ylabel("Revenue (USD)")
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax2.spines[["top", "right"]].set_visible(False)

fig.suptitle("Product Metrics — H1 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("product_metrics.png", dpi=150)
plt.show()
```

L'uso di `sharey=False` permette a ogni pannello di scalare in modo indipendente — il fatturato in dollari e il numero di utenti hanno ordini di grandezza diversi. Il `suptitle` aggiunge un titolo complessivo sopra entrambi i subplots.

> **Errore comune nei colloqui**
>
> I candidati spesso utilizzano `plt.plot()` per tutto invece dell'API orientata agli oggetti. Quando un intervistatore chiede di aggiungere un secondo asse y o di modificare un singolo subplot, l'approccio pyplot mostra i suoi limiti. L'API OO con `fig, ax = plt.subplots()` dovrebbe essere sempre la scelta predefinita.

## Grafici statistici con Seaborn: dalla distribuzione alla correlazione

Seaborn si basa su Matplotlib ed è specializzato nella visualizzazione statistica. Dove Matplotlib richiede configurazione manuale, Seaborn deduce impostazioni ragionevoli dalla struttura dei dati.

Un'analisi di distribuzione — uno dei compiti più comuni nei colloqui — richiede una sola chiamata a funzione:

```python
# distribution_analysis.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulare dati salariali per due dipartimenti
np.random.seed(42)
data = pd.DataFrame({
    "salary": np.concatenate([
        np.random.normal(75_000, 12_000, 200),  # Engineering
        np.random.normal(65_000, 10_000, 150),  # Marketing
    ]),
    "department": ["Engineering"] * 200 + ["Marketing"] * 150
})

# KDE plot per confrontare le distribuzioni salariali
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Suddivisione automatica per categoria
    fill=True,               # Area ombreggiata sotto la curva
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # Collegamento ai nostri axes espliciti
)

ax.set_title("Salary Distribution by Department")
ax.set_xlabel("Annual Salary (USD)")
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("salary_distribution.png", dpi=150)
plt.show()
```

Il parametro `hue` suddivide automaticamente i dati, mentre `fill=True` rende visibili le aree di sovrapposizione. Questo pattern — raggruppare distribuzioni per categoria — appare in praticamente ogni colloquio di analytics.

## Heatmap Seaborn per matrici di correlazione

Le heatmap di correlazione rivelano le relazioni tra variabili numeriche a colpo d'occhio. Gli intervistatori le utilizzano per verificare se i candidati riescono a identificare la multicollinearità o a individuare forti relazioni tra le feature.

```python
# correlation_heatmap.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulare metriche e-commerce
np.random.seed(42)
n = 500
page_views = np.random.poisson(15, n)
time_on_site = page_views * 2.5 + np.random.normal(0, 5, n)
cart_adds = np.random.binomial(page_views, 0.3)
purchases = np.random.binomial(cart_adds, 0.4)

df = pd.DataFrame({
    "page_views": page_views,
    "time_on_site": time_on_site,
    "cart_adds": cart_adds,
    "purchases": purchases
})

# Calcolare la correlazione di Pearson
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Mostrare i valori di correlazione nelle celle
    fmt=".2f",               # Due cifre decimali
    cmap="RdBu_r",           # Mappa di colori divergente centrata su 0
    vmin=-1, vmax=1,         # Scala fissa per coerenza
    square=True,             # Celle quadrate
    linewidths=0.5,
    ax=ax
)

ax.set_title("E-commerce Metrics Correlation")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()
```

La mappa di colori divergente `RdBu_r` rappresenta le correlazioni positive in blu e quelle negative in rosso — una convenzione che gli intervistatori si aspettano. L'impostazione `vmin=-1` e `vmax=1` garantisce che la scala cromatica rimanga interpretabile indipendentemente dall'intervallo effettivo dei dati.

## Stilizzare i grafici per presentazioni professionali

L'output predefinito di Matplotlib appare datato. Poche righe di configurazione trasformano i grafici in visualizzazioni pronte per la presentazione che dimostrano attenzione ai dettagli durante i colloqui.

```python
# professional_styling.py
import matplotlib.pyplot as plt
import seaborn as sns

# Applicare il tema integrato di Seaborn
sns.set_theme(
    style="whitegrid",       # Sfondo pulito con linee della griglia
    palette="muted",         # Palette di colori professionale
    font_scale=1.1           # Testo leggermente più grande
)

# Override globali di Matplotlib
plt.rcParams.update({
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "font.family": "sans-serif",
    "axes.titlesize": 14,
    "axes.labelsize": 12,
})
```

Applicare `sns.set_theme()` all'inizio di uno script propaga uno stile coerente a ogni grafico successivo. Durante i colloqui, questo evita di sprecare tempo nella formattazione dei singoli grafici.

> **Nota sulla versione**
>
> Seaborn 0.13 ha deprecato `set_style()` e `set_palette()` come chiamate separate. La funzione unificata `set_theme()` le sostituisce entrambe. Le risposte più vecchie su Stack Overflow fanno ancora riferimento all'API deprecata — nei colloqui del 2026 vanno evitate.

## Domande frequenti sulla visualizzazione dati nei colloqui

Oltre alla programmazione, gli intervistatori verificano la comprensione concettuale delle best practice di visualizzazione. Le seguenti domande compaiono regolarmente nei colloqui per data analytics e data science.

**Quando utilizzare un grafico a barre invece di un grafico a linee?**
I grafici a barre mostrano confronti tra categorie discrete (dipartimenti, tipi di prodotto, regioni). I grafici a linee mostrano tendenze su intervalli continui o ordinati (serie temporali, misurazioni sequenziali). Utilizzare un grafico a linee per categorie non ordinate suggerisce una falsa relazione tra i punti dati adiacenti.

**Cosa rende un grafico fuorviante?**
Assi y troncati, doppi assi y con scale diverse, effetti 3D su dati 2D e intervalli temporali selezionati ad hoc distorcono la percezione. La soluzione: iniziare l'asse y da zero per i grafici a barre, etichettare esplicitamente gli assi ed evitare elementi decorativi che oscurano i dati.

**In che modo la scelta della palette di colori influenza l'interpretazione dei dati?**
Le palette sequenziali (dal chiaro allo scuro) sono adatte per dati ordinati come temperatura o fatturato. Le palette divergenti (due tonalità che si incontrano in un centro neutro) evidenziano le deviazioni da un punto medio, come profitto/perdita o coefficienti di correlazione. Le palette categoriche utilizzano tonalità distinte per gruppi non correlati. Le palette accessibili ai daltonici (come `colorblind` o `muted` di Seaborn) garantiscono l'accessibilità — un dettaglio che distingue i candidati senior.

**Qual è la differenza tra `plt.show()` e `plt.savefig()`?**
`plt.show()` renderizza la figura in una finestra interattiva e cancella lo stato della figura successivamente. `plt.savefig()` scrive la figura su file senza cancellarla. Chiamare `savefig()` dopo `show()` produce un file vuoto — un bug comune. L'ordine corretto: prima `savefig()`, poi `show()`.

## Esercizio completo: simulazione di colloquio end-to-end

Un tipico esercizio da svolgere a casa o in sessione live combina caricamento dati, pulizia e diversi tipi di grafico. L'esempio seguente rispecchia le prove reali proposte dai team di analytics.

```python
# interview_exercise.py
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# Simulare 12 mesi di dati di prodotto
np.random.seed(42)
months = pd.date_range("2025-01", periods=12, freq="MS")
df = pd.DataFrame({
    "month": months,
    "revenue": np.cumsum(np.random.normal(5000, 2000, 12)) + 50_000,
    "customers": np.cumsum(np.random.poisson(50, 12)) + 500,
    "churn_rate": np.clip(np.random.normal(0.05, 0.015, 12), 0.01, 0.12)
})

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Pannello 1: Trend del fatturato
axes[0].plot(df["month"], df["revenue"], marker="o", color="#2563eb")
axes[0].set_title("Revenue Trend")
axes[0].set_ylabel("Revenue (USD)")
axes[0].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
axes[0].tick_params(axis="x", rotation=45)
axes[0].spines[["top", "right"]].set_visible(False)

# Pannello 2: Crescita clienti
axes[1].bar(df["month"], df["customers"], color="#16a34a", width=20)
axes[1].set_title("Customer Growth")
axes[1].set_ylabel("Total Customers")
axes[1].tick_params(axis="x", rotation=45)
axes[1].spines[["top", "right"]].set_visible(False)

# Pannello 3: Tasso di abbandono con linea di soglia
axes[2].plot(df["month"], df["churn_rate"], marker="s", color="#dc2626")
axes[2].axhline(y=0.05, color="gray", linestyle="--", label="Target: 5%")
axes[2].set_title("Monthly Churn Rate")
axes[2].set_ylabel("Churn Rate")
axes[2].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:.1%}"))
axes[2].tick_params(axis="x", rotation=45)
axes[2].spines[["top", "right"]].set_visible(False)
axes[2].legend()

fig.suptitle("Product Dashboard — FY 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("interview_dashboard.png", dpi=150)
plt.show()
```

Questo esercizio dimostra tre tipi di grafico in un layout unificato, formattazione corretta degli assi, una linea di riferimento per gli obiettivi di churn e uno stile coerente. Questi sono esattamente gli elementi che gli intervistatori valutano.

## Conclusione

- L'API orientata agli oggetti di Matplotlib (`fig, ax = plt.subplots()`) offre il pieno controllo ed è lo standard atteso in contesti professionali e nei colloqui
- Il parametro `hue` di Seaborn e le funzioni statistiche integrate (KDE, heatmap) gestiscono analisi raggruppate con codice minimo
- Le heatmap di correlazione con mappe di colori divergenti e scale fisse (`vmin=-1, vmax=1`) sono un elemento ricorrente nei colloqui di analytics
- Chiamare sempre `savefig()` prima di `show()` per evitare file di output vuoti
- Uno stile curato — spines rimossi, etichette dei tick formattate, titoli espliciti — comunica agli intervistatori un approccio di qualità produttiva
- Esercitarsi nella costruzione di dashboard multi-pannello sotto pressione temporale: la maggior parte delle sessioni di live coding assegna 10-15 minuti per ogni attività di visualizzazione

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/it/blog/data-analytics/python-matplotlib-seaborn-data-visualization-interview