Librerie Python per data science — pandas, numpy e matplotlib per decisioni che pesano sul fatturato

Il tuo gestionale ti sputa un CSV con 40.000 righe di vendite e tu devi capire quali prodotti rendono davvero. Aprire Excel significa aspettare dieci minuti e poi impazzire con i filtri. Oppure hai un cliente che ti chiede un'analisi dei dati di traffico e devi trasformare numeri grezzi in un grafico che parli chiaro. Le librerie Python per data science — pandas, numpy e matplotlib — sono gli strumenti con cui risolviamo questi problemi ogni giorno. Non servono per fare ricerca accademica: servono per prendere decisioni operative con numeri certi.

Noi, di Meteora Web, veniamo dalla contabilità: bilanci, partita doppia, IVA. Quando affrontiamo un progetto di analisi dati, ragioniamo in termini di margini e ritorno, non di grafici carini. Con queste tre librerie puoi pulire dati sporchi, calcolare marginalità per prodotto, prevedere picchi di domanda e presentare tutto con un grafico che il tuo cliente capisce al primo sguardo. In questa guida pratica vediamo come usarle davvero, con esempi copia-incolla che funzionano.

Perché pandas, numpy e matplotlib sono il trio che ti serve per l'analisi dati?

Ogni libreria ha un ruolo preciso, come in un reparto aziendale. numpy gestisce gli array numerici e le operazioni matematiche ad alte prestazioni: è il motore di calcolo. pandas lavora su dati tabellari (le tue tabelle, i tuoi CSV, i tuoi fogli Excel) e ti permette di filtrare, aggregare, unire e trasformare i dati con poche righe di codice. matplotlib trasforma i risultati in grafici: istogrammi, linee, scatter plot, heatmap. Insieme coprono l'intero flusso: carichi, pulisci, analizzi, visualizzi.

Un errore comune è pensare che basti pandas. Ma senza numpy, le operazioni su grandi volumi di dati diventano lentissime. Senza matplotlib, i tuoi risultati restano numeri astratti che nessuno legge. Il trio funziona perché ogni pezzo fa il suo mestiere. Noi lo usiamo per analizzare i dati di vendita dei clienti e-commerce: con poche righe calcoliamo quale prodotto ha il margine migliore per stagione, quale categoria va spinta in advertising e quale va scontata per fare spazio in magazzino. Un lavoro che in Excel richiederebbe ore, con Python richiede minuti.

Come installare le librerie e preparare l'ambiente di lavoro

Prima di scrivere codice, devi avere le librerie installate. Il modo più semplice è usare pip, il gestore di pacchetti di Python:

pip install pandas numpy matplotlib

Se lavori in un ambiente virtuale (e dovresti), attivalo prima. Per chi usa Anaconda, il comando è simile. Dopo l'installazione, verifica che tutto funzioni importando le librerie:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

print(pd.__version__)
print(np.__version__)

Se vedi i numeri di versione, sei pronto. Non serve altro. Ora passiamo al lavoro vero.

Come si pulisce un dataset sporco con pandas e numpy?

Il 90% del lavoro nella data science è pulire i dati. I CSV che ti arrivano dai clienti hanno sempre problemi: colonne con nomi inconsistenti, valori mancanti, duplicati, formati di data sbagliati. Se non pulisci, ogni analisi successiva è inaffidabile. Un cliente e-commerce aveva un file con le vendite di tre anni: 15.000 righe, ma con date in formato misto e alcuni prezzi negativi (errori di importazione). Con tre righe di pandas abbiamo normalizzato tutto.

Ecco uno script che gestisce i problemi più comuni:

import pandas as pd
import numpy as np

# Carica il CSV
# df = pd.read_csv('vendite.csv')
# Crea un DataFrame di esempio per testare
df = pd.DataFrame({
    'prodotto': ['A', 'B', 'A', 'C', 'B', None],
    'prezzo': [10.5, 20.0, 10.0, 15.0, 20.5, 30.0],
    'quantita': [2, 1, 3, None, 2, 1],
    'data': ['2025-01-01', '2025-01-02', '2025-01-01', '2025-01-03', '2025-01-02', '2025-01-04']
})

# 1. Rimuovi duplicati
df = df.drop_duplicates()

# 2. Gestisci valori mancanti: riempi con la media per colonne numeriche
df['quantita'] = df['quantita'].fillna(df['quantita'].mean())

# 3. Rimuovi righe con dati critici mancanti (es. prodotto)
df = df.dropna(subset=['prodotto'])

# 4. Converti la data in formato datetime
df['data'] = pd.to_datetime(df['data'])

# 5. Filtra valori anomali: prezzo negativo o zero
# df = df[df['prezzo'] > 0]

print(df)

Questo è il punto di partenza per qualsiasi analisi. Con drop_duplicates elimini le righe duplicate, con fillna gestisci i valori mancanti, con dropna rimuovi le righe senza informazioni essenziali. La conversione delle date è fondamentale: senza, non puoi fare analisi temporali.

Come gestire i valori mancanti senza falsare i risultati

La scelta di come riempire i valori mancanti dipende dal contesto. Se hai la quantità mancante in una vendita, puoi usare la media delle altre vendite. Ma se hai una colonna come il codice fiscale del cliente, riempire con la media non ha senso. In quel caso, meglio eliminare le righe o usare un valore sentinella. Il nostro consiglio: documenta sempre cosa fai. Se il cliente ti chiede come hai gestito i dati mancanti, devi saperlo spiegare. Un'analisi con dati inventati è peggio di nessuna analisi.

Come calcolare KPI di vendita e marginalità con pandas e numpy?

Una volta puliti i dati, inizia la parte interessante: estrarre informazioni utili. Per un e-commerce, i KPI fondamentali sono fatturato totale, margine medio per prodotto, vendite per categoria, andamento nel tempo. Con pandas si fa in poche righe.

import pandas as pd
import numpy as np

# DataFrame di esempio con vendite
df = pd.DataFrame({
    'prodotto': ['A', 'B', 'A', 'C', 'B', 'A'],
    'categoria': ['Tech', 'Casa', 'Tech', 'Casa', 'Casa', 'Tech'],
    'prezzo': [10.5, 20.0, 10.0, 15.0, 20.5, 11.0],
    'costo': [5.0, 12.0, 4.5, 9.0, 11.0, 5.5],
    'quantita': [2, 1, 3, 1, 2, 4],
    'data': pd.to_datetime(['2025-01-01', '2025-01-02', '2025-01-01', '2025-01-03', '2025-01-02', '2025-01-04'])
})

# Calcola fatturato e margine per riga
df['fatturato'] = df['prezzo'] * df['quantita']
df['margine'] = (df['prezzo'] - df['costo']) * df['quantita']

# Totale fatturato e margine
print('Fatturato totale:', df['fatturato'].sum())
print('Margine totale:', df['margine'].sum())

# Margine medio per prodotto
margine_per_prodotto = df.groupby('prodotto')['margine'].mean()
print('\nMargine medio per prodotto:')
print(margine_per_prodotto)

# Vendite per categoria
vendite_per_categoria = df.groupby('categoria')['quantita'].sum()
print('\nQuantità venduta per categoria:')
print(vendite_per_categoria)

# Andamento giornaliero del fatturato
andamento = df.groupby('data')['fatturato'].sum()
print('\nAndamento giornaliero:')
print(andamento)

Con groupby aggreghi i dati per categoria, prodotto o data. Con sum e mean calcoli totali e medie. Questo è il cuore dell'analisi: capire dove si fa margine e dove si perde. Noi lo usiamo per decidere quali prodotti mettere in promozione: se un prodotto ha margine alto ma vende poco, forse va spinto con advertising. Se ha margine basso e vende tanto, forse va rinegoziato il costo fornitore.

Come usare numpy per calcoli vettoriali veloci

Quando i dati crescono, pandas usa numpy sotto il cofano. Ma a volte serve intervenire direttamente con numpy per calcoli personalizzati. Per esempio, calcolare il margine percentuale per ogni prodotto:

import numpy as np

# Converti le colonne in array numpy
prezzi = df['prezzo'].to_numpy()
costi = df['costo'].to_numpy()

# Calcola il margine percentuale vettorialmente
margine_perc = (prezzi - costi) / prezzi * 100
print('Margine percentuale per riga:')
print(margine_perc)

# Calcola la media del margine percentuale
print('Margine percentuale medio:', np.mean(margine_perc))

Con numpy, le operazioni si applicano a interi array senza cicli for. È più veloce e più leggibile. np.mean, np.sum, np.std sono i mattoni per qualsiasi statistica descrittiva. Se devi calcolare la deviazione standard delle vendite per capire la stagionalità, numpy ti dà la risposta in una riga.

Come visualizzare i dati con matplotlib per presentarli al cliente?

I numeri da soli non bastano. Un grafico ben fatto comunica in un secondo quello che una tabella dice in dieci minuti. Con matplotlib creiamo grafici professionali da inserire in report o presentazioni. Ecco come visualizzare l'andamento delle vendite e la distribuzione per categoria.

import matplotlib.pyplot as plt
import pandas as pd

# Usa il DataFrame dell'esempio precedente
# andamento = df.groupby('data')['fatturato'].sum()

# Grafico a linee per l'andamento del fatturato
plt.figure(figsize=(10, 5))
plt.plot(andamento.index, andamento.values, marker='o', linestyle='-', color='#2E86AB')
plt.title('Andamento del fatturato giornaliero')
plt.xlabel('Data')
plt.ylabel('Fatturato (€)')
plt.grid(True, linestyle='--', alpha=0.6)
plt.tight_layout()
plt.show()

# Grafico a barre per le vendite per categoria
vendite_per_categoria = df.groupby('categoria')['quantita'].sum()
plt.figure(figsize=(8, 5))
plt.bar(vendite_per_categoria.index, vendite_per_categoria.values, color=['#F18F01', '#C73E1D'])
plt.title('Quantità venduta per categoria')
plt.xlabel('Categoria')
plt.ylabel('Quantità')
plt.tight_layout()
plt.show()

Con plt.plot crei grafici a linee, con plt.bar grafici a barre. Puoi salvare i grafici come file PNG o PDF con plt.savefig('grafico.png', dpi=150). Noi consigliamo di usare colori aziendali del cliente per i report: un piccolo dettaglio che fa la differenza percepita.

Come personalizzare i grafici per un report professionale

Un grafico standard va bene per un'analisi interna, ma per un cliente serve cura. Aggiungi titoli chiari, etichette sugli assi, legende se hai più serie. Puoi cambiare stile con plt.style.use('ggplot') o 'seaborn-v0_8' per un look più moderno. Ecco un esempio con legenda e annotazioni:

import matplotlib.pyplot as plt
import numpy as np

# Dati di esempio
mesi = ['Gen', 'Feb', 'Mar', 'Apr']
vendite_2025 = [12000, 15000, 13000, 18000]
vendite_2026 = [14000, 16000, 15000, 20000]

plt.figure(figsize=(10, 6))
plt.plot(mesi, vendite_2025, marker='o', label='2025')
plt.plot(mesi, vendite_2026, marker='s', label='2026')
plt.title('Confronto vendite 2025 vs 2026')
plt.xlabel('Mese')
plt.ylabel('Fatturato (€)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)

# Annota il punto di picco
plt.annotate('Picco 2026', xy=('Apr', 20000), xytext=('Mar', 19000),
             arrowprops=dict(arrowstyle='->', color='red'))
plt.tight_layout()
plt.show()

Le annotazioni con plt.annotate mettono in evidenza i punti chiave. Il cliente non deve cercare il picco: glielo indichi tu. Questo è il valore che aggiungiamo come agenzia: non solo dati, ma interpretazione visiva immediata.

Come automatizzare l'analisi dati per decisioni ricorrenti?

Il vero salto di qualità è automatizzare. Invece di aprire il CSV ogni mese e rifare tutto a mano, scrivi uno script che fa tutto da solo e ti manda il report via email. Noi lo facciamo per i clienti con report mensili automatici: lo script legge i dati, calcola i KPI, genera i grafici e invia tutto via email. Il cliente riceve il PDF e non deve chiedere nulla.

Ecco la struttura di uno script di automazione:

import pandas as pd
import matplotlib.pyplot as plt
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders

# Funzione per analizzare i dati
def analizza_dati(file_path):
    df = pd.read_csv(file_path)
    # ... pulizia e calcoli ...
    return df

# Funzione per generare il grafico
def genera_grafico(df, output_path):
    andamento = df.groupby('data')['fatturato'].sum()
    plt.figure(figsize=(10, 5))
    plt.plot(andamento.index, andamento.values)
    plt.title('Andamento vendite')
    plt.savefig(output_path, dpi=150)

# Funzione per inviare email con allegato
def invia_email(destinatario, allegato):
    # Configura SMTP (esempio con Gmail)
    # ...
    pass

# Esecuzione principale
if __name__ == '__main__':
    df = analizza_dati('vendite_mensili.csv')
    genera_grafico(df, 'report_mensile.png')
    invia_email('cliente@azienda.it', 'report_mensile.png')
    print('Report inviato con successo.')

Con uno script così, l'analisi dati diventa un processo ripetibile. Puoi schedularlo con cron su Linux o con Task Scheduler su Windows. Il tempo risparmiato è enorme: invece di due ore al mese, spendi dieci minuti per controllare che tutto funzioni. E il cliente apprezza la puntualità.

Come schedulare l'analisi con cron su Linux

Se il tuo server è Linux, aggiungi una riga al crontab per eseguire lo script ogni primo del mese:

0 8 1 * * cd /path/to/script && /usr/bin/python3 analisi.py

Questo comando esegue lo script alle 8:00 del primo giorno di ogni mese. Assicurati che il percorso a Python sia corretto con which python3. La schedulazione è il passo finale per trasformare un'analisi in un servizio continuo.

Quali errori comuni evitare nell'uso delle librerie Python per data science?

Il primo errore è non pulire i dati prima di analizzarli. Se il tuo dataset ha duplicati o valori mancanti, i KPI sono sbagliati e il cliente perde fiducia. Il secondo errore è usare cicli for al posto delle operazioni vettoriali di numpy: su grandi dataset, il codice diventa lentissimo. Il terzo errore è non documentare il codice: se tra sei mesi devi modificare lo script, senza commenti perdi ore.

Un altro errore tipico è ignorare i tipi di dato. Se la colonna prezzo è letta come stringa, non puoi fare calcoli. Controlla sempre con df.dtypes e converti con pd.to_numeric se serve. E infine, non fidarti dei grafici senza contesto: un grafico senza titolo e senza etichette non dice nulla. Noi, di Meteora Web, abbiamo visto troppi report inutili perché mancava il contesto.

Come evitare errori di conversione e tipo di dato

Quando carichi un CSV, pandas fa del suo meglio per indovinare i tipi, ma spesso sbaglia. Ecco come forzare la conversione:

import pandas as pd

# Forza la conversione delle colonne
df = pd.read_csv('vendite.csv', dtype={'prezzo': 'float64', 'quantita': 'int32'})

# Oppure converti dopo il caricamento
df['prezzo'] = pd.to_numeric(df['prezzo'], errors='coerce')
df['data'] = pd.to_datetime(df['data'], errors='coerce')

# Controlla i tipi risultanti
print(df.dtypes)

Con errors='coerce', i valori non convertibili diventano NaN, che poi gestisci come abbiamo visto. Questo evita che un errore di battitura nel CSV faccia fallire l'intera analisi. La robustezza è tutto quando lavori con dati reali.

Come integrare queste librerie in un flusso di lavoro per un cliente?

Immagina di avere un cliente che vende online e ti chiede di capire perché le vendite sono calate. Il flusso è: estrai i dati dal suo e-commerce (CSV o API), puliscili, analizza le vendite per mese, prodotto, canale di acquisizione, e genera un report con grafici. Le librerie Python per data science sono il motore di questo processo. Noi lo facciamo quotidianamente, e il risultato è che il cliente sa esattamente dove intervenire: forse una categoria specifica è in calo, o un canale advertising non rende.

La cosa bella è che non serve un data scientist: con queste tre librerie e un po' di pratica, un sviluppatore web può fare analisi potenti. La curva di apprendimento è breve, soprattutto se conosci già Python. E i benefici sono immediati: decisioni basate su dati, non su intuizioni.

Come presentare i risultati al cliente in modo efficace

Non consegnare solo il codice. Prepara un documento con i grafici e le conclusioni principali. Spiega cosa significa ogni numero e cosa consigli di fare. Per esempio: "Il margine medio del prodotto X è del 30%, ma le vendite sono calate del 15% nell'ultimo trimestre. Suggeriamo di lanciare una promozione mirata o di rivedere il posizionamento." Questo è il valore che un'agenzia come la nostra aggiunge: trasformare i dati in azioni.

Per approfondire l'uso di Python nello sviluppo web, ti rimandiamo alla nostra guida completa su Python per sviluppatori. E se vuoi vedere come queste librerie si integrano con applicazioni web, dai un'occhiata al nostro articolo su agenti AI e automazione.

Cosa fare adesso

Ecco le azioni concrete per iniziare subito con le librerie Python per data science:

• Installa le librerie nel tuo ambiente virtuale: pip install pandas numpy matplotlib.
• Prendi un dataset reale (anche il tuo file di vendite) e applica la pulizia: duplicati, valori mancanti, tipi di dato.
• Calcola 3 KPI: fatturato totale, margine medio, vendite per categoria. Usa groupby e sum.
• Genera un grafico dell'andamento delle vendite e salvalo come PNG con plt.savefig.
• Automatizza il processo con uno script e schedulalo con cron.

Non serve altro per partire. La differenza tra un'analisi fatta bene e una fatta male è la pulizia dei dati e la chiarezza della presentazione. Con queste tre librerie hai tutto quello che serve. Noi le usiamo ogni giorno e possiamo aiutarti a implementare un sistema di analisi dati per la tua azienda o per i tuoi clienti. Se vuoi, contattaci.