Grafica con Python - librerie, grafici e interfacce

Creare grafici, finestre e strumenti visuali con Python è più semplice quando si parte dal tipo di risultato da ottenere. In questa guida mostro quali librerie scegliere, come costruire una prima visualizzazione, come collegarla a un database e quali limiti considerare prima di trasformare uno script in una vera applicazione.

Che cosa si può fare con la grafica in Python

Quando si parla di grafica in Python, si intendono almeno tre scenari diversi. Il primo è la visualizzazione dei dati, con grafici a linee, barre, dispersioni, istogrammi e mappe. Il secondo riguarda le interfacce grafiche desktop, cioè finestre con pulsanti, tabelle, menu e moduli.

Il terzo comprende animazioni, simulazioni e videogiochi 2D. Questa distinzione è importante perché non esiste una libreria migliore in assoluto: Matplotlib risolve bene un report analitico, ma non è lo strumento giusto per costruire un videogioco o un gestionale completo.

Io parto sempre da una domanda concreta: il risultato deve essere un’immagine da esportare, una pagina web interattiva o un programma che l’utente utilizza facendo clic? La risposta riduce subito il numero di alternative e impedisce di aggiungere dipendenze inutili al progetto.

Le librerie più utili per ogni progetto

Per i grafici tradizionali sceglierei Matplotlib. La documentazione ufficiale la descrive come una libreria per visualizzazioni statiche, animate e interattive, con un’API a oggetti basata su figure e assi. In pratica, offre un controllo molto fine su etichette, colori, scale e formati di esportazione.

Plotly è più convincente quando il lettore deve esplorare i dati. I grafici possono essere visualizzati in notebook, esportati in HTML oppure integrati in applicazioni Dash. La sua comodità si paga con una maggiore complessità di distribuzione, soprattutto quando il progetto deve funzionare su più computer.

Per una finestra semplice basta spesso Tkinter. Per un’applicazione con più schermate, tabelle, modelli dati e un’interfaccia curata preferisco PySide6, il binding ufficiale di Qt6 per Python. Include anche strumenti come Qt Designer, utile per progettare visivamente i layout.

Come creare il primo grafico con Matplotlib

Per iniziare è sufficiente un ambiente virtuale e l’installazione del pacchetto. Un ambiente separato evita conflitti tra versioni e rende più facile distribuire il progetto.

python -m venv .venv

# Linux e macOS
source .venv/bin/activate

# Windows
.venv\Scripts\activate

pip install matplotlib

Questo esempio mostra l’andamento mensile delle vendite. Uso l’interfaccia a oggetti perché rimane più ordinata quando il grafico cresce o deve essere inserito in una GUI.

import matplotlib.pyplot as plt

mesi = ["Gen", "Feb", "Mar", "Apr", "Mag", "Giu"]
vendite = [120, 145, 138, 172, 190, 215]

fig, ax = plt.subplots(figsize=(8, 4.5))
ax.plot(mesi, vendite, marker="o", color="#1769aa")
ax.set_title("Vendite del primo semestre")
ax.set_xlabel("Mese")
ax.set_ylabel("Unità vendute")
ax.grid(alpha=0.25)

fig.tight_layout()
fig.savefig("vendite.png", dpi=150)
plt.show()

La chiamata a savefig() produce un file PNG riutilizzabile in un report o in una pagina web. Il parametro `dpi=150` è sufficiente per il web e per documenti comuni; per la stampa si può salire a 300, aumentando però dimensione e tempo di generazione.

Un errore frequente consiste nel creare un grafico senza titoli, unità di misura o scala leggibile. Un grafico tecnicamente corretto può comunque comunicare male: preferisco pochi colori, una legenda solo quando serve e assi comprensibili anche a chi non ha scritto il codice.

Quando servono grafici interattivi e dashboard

Se l’utente deve filtrare un periodo, leggere il valore passando sul punto o ingrandire una zona del grafico, una semplice immagine non basta. In questo caso Plotly offre un’interazione pronta, mentre Dash permette di costruire una dashboard web in Python senza dover scrivere tutta la logica dell’interfaccia in JavaScript.

import plotly.express as px

mesi = ["Gen", "Feb", "Mar", "Apr", "Mag", "Giu"]
vendite = [120, 145, 138, 172, 190, 215]

figura = px.line(
    x=mesi,
    y=vendite,
    markers=True,
    labels={"x": "Mese", "y": "Unità vendute"},
    title="Vendite del primo semestre"
)

figura.write_html("vendite_interattive.html")
figura.show()

Il file HTML può essere aperto direttamente nel browser e conserva zoom e tooltip. Per una condivisione interna è spesso la soluzione più rapida; per un prodotto destinato a molti utenti bisogna invece pensare a autenticazione, aggiornamento dei dati, hosting e controllo dei costi.

Non userei Plotly solo perché “sembra più moderno”. Se il grafico deve finire in un PDF immutabile, Matplotlib è spesso più prevedibile. L’interattività ha valore quando aiuta a prendere una decisione, non quando aggiunge soltanto animazioni decorative.

Come costruire un’interfaccia desktop

Una finestra essenziale con Tkinter

Tkinter è una buona palestra per capire il modello a eventi. Il programma crea i componenti, collega ogni pulsante a una funzione e avvia il main loop, cioè il ciclo che ascolta clic, tasti e aggiornamenti della finestra.

import tkinter as tk
from tkinter import ttk

def saluta():
    risultato.config(text=f"Ciao, {nome.get()}!")

finestra = tk.Tk()
finestra.title("Esempio Python")
finestra.geometry("320x180")

nome = tk.StringVar()
ttk.Label(finestra, text="Il tuo nome").pack(pady=(20, 4))
ttk.Entry(finestra, textvariable=nome).pack()
ttk.Button(finestra, text="Conferma", command=saluta).pack(pady=12)

risultato = ttk.Label(finestra, text="")
risultato.pack()

finestra.mainloop()

Il vantaggio concreto è l’assenza di una dipendenza obbligatoria da installare. L’aspetto predefinito può risultare datato e i layout complessi diventano difficili da mantenere, ma per utility personali, strumenti amministrativi e prototipi Tkinter resta efficiente.

Leggi anche: Creare un’app Android con Python - Kivy, SQLite e APK

Quando passare a PySide6

PySide6 è più adatto quando servono menu articolati, tabelle, finestre multiple, temi grafici e una base pronta per crescere. L’installazione ufficiale richiede Python 3.9 o superiore e può essere eseguita con `pip install pyside6` dentro un ambiente virtuale.

import sys
from PySide6.QtWidgets import QApplication, QLabel, QWidget

app = QApplication(sys.argv)

finestra = QWidget()
finestra.setWindowTitle("Applicazione Qt")
finestra.resize(360, 180)

etichetta = QLabel("Interfaccia pronta", parent=finestra)
etichetta.move(120, 75)

finestra.show()
sys.exit(app.exec())

In un progetto reale separerei interfaccia, logica e accesso ai dati. Mescolare query SQL, calcoli e codice dei pulsanti nello stesso file funziona per una demo, ma diventa rapidamente fragile quando cambiano requisiti o schermate.

Collegare grafici e database senza complicare il progetto

La grafica diventa davvero utile quando non dipende da valori scritti a mano. Per un’applicazione locale, SQLite è spesso sufficiente: non richiede un server separato e salva tutto in un singolo file. Per dati aziendali condivisi si può passare a PostgreSQL o a un altro database gestito, mantenendo separato il livello di accesso.

import sqlite3
import pandas as pd
import matplotlib.pyplot as plt

connessione = sqlite3.connect("vendite.db")

query = """
SELECT mese, SUM(importo) AS totale
FROM ordini
GROUP BY mese
ORDER BY mese
"""

dati = pd.read_sql_query(query, connessione)

fig, ax = plt.subplots(figsize=(8, 4.5))
ax.bar(dati["mese"], dati["totale"], color="#2e7d32")
ax.set_title("Fatturato mensile")
ax.set_ylabel("Euro")
fig.tight_layout()
plt.show()

connessione.close()

Qui pandas trasforma il risultato SQL in una tabella facilmente utilizzabile dalla libreria grafica. Il passaggio decisivo è la query: se il database contiene dati duplicati, date incoerenti o importi memorizzati come testo, il grafico sarà elegante ma sbagliato.

Per questo controllo sempre tre aspetti prima di visualizzare i risultati. Verifico che le date siano ordinate, che i valori mancanti abbiano un trattamento esplicito e che l’aggregazione corrisponda alla domanda aziendale. Un totale mensile e una media giornaliera rispondono a esigenze diverse, anche se partono dalla stessa tabella.

Prestazioni, errori e distribuzione dell’applicazione

Per poche migliaia di righe, Matplotlib o Plotly lavorano senza particolari problemi. Con milioni di record conviene aggregare nel database, limitare l’intervallo temporale e caricare soltanto le colonne necessarie. Disegnare ogni riga sullo schermo è quasi sempre uno spreco.

Nelle interfacce desktop bisogna evitare operazioni lente dentro il thread grafico. Una query lunga o un’elaborazione di immagini può congelare la finestra; con PySide6 si usano thread o attività asincrone, mentre con Tkinter è importante non bloccare il main loop.

Prima della distribuzione testo il programma su ogni sistema operativo previsto. Un ambiente virtuale non basta a garantire un eseguibile funzionante: occorre verificare percorsi dei file, font, backend grafici, driver e permessi di scrittura. Per applicazioni interne, strumenti come PyInstaller possono semplificare il rilascio, ma l’eseguibile finale può occupare decine o centinaia di megabyte perché include l’interprete e le dipendenze.

Un altro punto spesso sottovalutato è la licenza. Matplotlib, Plotly, Pygame e PySide6 hanno condizioni diverse, soprattutto se il software viene venduto o distribuito con componenti proprietari. Prima di pubblicare un prodotto controllo sempre le licenze dei pacchetti e delle risorse grafiche incluse.

Una decisione pratica per iniziare senza rifare tutto

Per un percorso lineare sceglierei Matplotlib più pandas se il primo obiettivo è analizzare dati. Aggiungerei Plotly quando servono filtri e interazioni, Tkinter per una piccola utility locale e PySide6 quando l’applicazione deve diventare uno strumento desktop completo.

• Grafico per un report: Matplotlib.
• Dashboard nel browser: Plotly e Dash.
• Finestra semplice: Tkinter.
• Gestionale desktop multipiattaforma: PySide6.
• Animazione o gioco 2D: Pygame.

Il consiglio che seguo anche nei progetti nuovi è costruire prima una versione piccola ma completa. Un grafico collegato a una query reale, con un filtro e un messaggio d’errore chiaro, insegna più di un’interfaccia ricca che mostra dati fittizi. Da quella base si può crescere senza perdere il controllo del codice.

Il dettaglio che rende utile una grafica ben progettata

La qualità non dipende soltanto dalla libreria scelta. Dipende da quanto rapidamente l’utente capisce che cosa sta guardando e quale decisione può prendere. Titoli descrittivi, unità corrette, colori coerenti e dati aggiornati fanno più differenza di effetti visivi complessi.

Python è quindi una scelta molto equilibrata per unire programmazione, analisi e interfacce. Partendo dal caso d’uso, mantenendo separati dati e presentazione e verificando i limiti di prestazioni e distribuzione, puoi trasformare uno script in uno strumento visuale affidabile.