venerdì 24 ottobre 2025

Corso di Python: 11 – Introduzione a Data Science e Web

11 Introduzione a Data Science e Web

Obiettivi didattici

  • Imparare le basi di NumPy e Pandas per manipolare array e dataset.

  • Creare grafici semplici con Matplotlib.

  • Realizzare una mini-app web con Flask che mostri una dashboard semplice (tabella + grafico).

  • Esercizio guidato: dashboard con Pandas + Matplotlib integrata in Flask.

1) Ambiente e pacchetti (pratico, 10 min)

Installare in un ambiente virtuale i pacchetti necessari:

python -m venv venv
# attiva il venv (Windows)
venv\Scripts\activate
# o (Mac/Linux)
source venv/bin/activate

pip install numpy pandas matplotlib flask

2) NumPy — array numerici e operazioni fondamentali (30–40 min)

Cos’è NumPy

  • Library per array multidimensionali efficienti (ndarray) e operazioni vettoriali.

Concetti chiave

  • ndarray: struttura dati centrale.

  • Operazioni vettoriali (somma, prodotto) vettorizzate senza loop Python.

  • Broadcasting: operazioni tra array di forme differenti compatibili.

Esempi pratici

Creare array e operazioni:

import numpy as np

# Creare array
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Operazioni vettoriali
c = a + b          # [5, 7, 9]
d = a * 2          # [2, 4, 6]
dot = a @ b        # prodotto scalare = 1*4 + 2*5 + 3*6 = 32

# Array 2D (matrici)
M = np.array([[1,2],[3,4]])
eigvals, eigvecs = np.linalg.eig(M)  # autovalori/autovettori

# Statistiche
mean = a.mean()    # 2.0
std = a.std()      # deviazione standard

Nota pratica: usare np.where, np.mean(axis=0/1), np.sum(axis=...) per aggregazioni.

3) Pandas — strutture dati e operazioni su dataset (1 ora)

Cos’è Pandas

  • Biblioteca per manipolare dati tabulari con due strutture principali:

    • Series: vettore indicizzato.

    • DataFrame: tabella con etichette per righe e colonne.

Lettura dati

  • pd.read_csv("file.csv"), pd.read_excel(...), pd.read_sql(...).

Operazioni comuni

  • .head(), .info(), .describe()

  • Selezione colonne: df["col"] o df.loc[:,["c1","c2"]]

  • Filtri: df[df["col"] > 10]

  • Groupby e aggregazioni: df.groupby("cat").agg({"sales":"sum", "qty":"mean"})

  • Merge / join: pd.merge(df1, df2, on="key")

  • Trattamento valori mancanti: df.dropna(), df.fillna(value)

Esempio pratico con dataset di esempio (sales.csv)

Supponiamo file sales.csv con colonne: date, region, product, sales, quantity.

import pandas as pd

# Carica dati
df = pd.read_csv("sales.csv", parse_dates=["date"])

# Ispezione
print(df.head())
print(df.info())
print(df.describe())

# Aggiungi colonne utili
df["month"] = df["date"].dt.to_period("M")   # mese
df["revenue_per_item"] = df["sales"] / df["quantity"]

# Aggregazione: vendite mensili per regione
monthly = df.groupby(["month", "region"]).agg(total_sales=("sales","sum"),
                                              total_qty=("quantity","sum")).reset_index()

# Ordina e mostra
monthly = monthly.sort_values(["month","region"])
print(monthly.head())

Esempio di pulizia

# Rimuovi righe con sales <= 0
df = df[df["sales"] > 0]

# Riempire valori mancanti nella colonna product con 'Unknown'
df["product"] = df["product"].fillna("Unknown")

4) Matplotlib — grafici base (40 min)

Concepts

  • figure, axes: contesto del grafico.

  • Plot di linea, barre, istogrammi, scatter, pie.

  • Personalizzare etichette, titolo, legenda.

Esempi

Grafico vendite mensili (da monthly creato sopra):

import matplotlib.pyplot as plt

# Filtriamo per una regione (esempio)
reg = "North"
data_reg = monthly[monthly["region"] == reg]

# Converti month period in string per plotting
x = data_reg["month"].astype(str)
y = data_reg["total_sales"]

plt.figure(figsize=(8,4))
plt.plot(x, y, marker='o')
plt.title(f"Vendite mensili - {reg}")
plt.xlabel("Mese")
plt.ylabel("Vendite totali")
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()

Bar chart per prodotto:

prod_sum = df.groupby("product")["sales"].sum().sort_values(ascending=False).head(10)
prod_sum.plot(kind="bar", figsize=(8,4))
plt.title("Top 10 prodotti per vendite")
plt.ylabel("Vendite")
plt.tight_layout()
plt.show()

Salvare figure come PNG (utile per integrare in una web app):

plt.savefig("vendite_mensili.png", dpi=150)

5) Flask — mini-app web (1 ora)

Cos’è Flask

  • Micro-framework Python per creare applicazioni web leggere.

File minimo app.py

from flask import Flask, render_template, send_file, make_response
import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO

app = Flask(__name__)

# Home: mostra tabella e grafico
@app.route("/")
def index():
    df = pd.read_csv("sales.csv", parse_dates=["date"])
    # calcolo rapido
    summary = df.groupby("region")["sales"].sum().reset_index()
    # converti in HTML
    table_html = summary.to_html(index=False, classes="table")
    return f"<h1>Dashboard</h1>{table_html}<br><img src='/plot.png' />"

# Route che fornisce il grafico come immagine PNG
@app.route("/plot.png")
def plot_png():
    df = pd.read_csv("sales.csv", parse_dates=["date"])
    monthly = df.groupby([df["date"].dt.to_period("M"), "region"])["sales"].sum().unstack(fill_value=0)
    # Grafico: vendite mensili per regione (linee)
    fig, ax = plt.subplots(figsize=(8,4))
    monthly.index = monthly.index.astype(str)
    monthly.plot(ax=ax)
    ax.set_title("Vendite mensili per regione")
    ax.set_xlabel("Mese")
    ax.set_ylabel("Vendite")
    ax.legend(title="Regione")
    fig.tight_layout()

    # Converti in PNG in memoria
    buf = BytesIO()
    fig.savefig(buf, format="png", dpi=100)
    plt.close(fig)
    buf.seek(0)
    return send_file(buf, mimetype='image/png')

if __name__ == "__main__":
    app.run(debug=True)

Spiegazioni

  • index() costruisce una versione HTML molto semplice: tabella (HTML) e immagine caricata via /plot.png.

  • /plot.png crea il grafico con Matplotlib, salva in memoria (BytesIO) e lo invia via send_file.

  • In produzione si userebbe render_template con file HTML in templates/ e static CSS/JS.

6) Esercizio guidato: Dashboard semplice con Pandas + Matplotlib (step-by-step)

Obiettivo: realizzare una piccola dashboard che carica sales.csv, mostra:

  • Tabella riepilogativa per regione.

  • Grafico vendite mensili per regione.

  • Un box con KPI: totale vendite, numero transazioni, vendite medie per transazione.

Dataset di esempio (sales.csv) — struttura consigliata:

  • date (YYYY-MM-DD)

  • region (string)

  • product (string)

  • sales (float)

  • quantity (int)

Passi

  1. Carica dati e ispeziona

df = pd.read_csv("sales.csv", parse_dates=["date"])
print(df.head())

  1. Pulizia minima

df = df.dropna(subset=["date","sales","region"])
df = df[df["sales"] >= 0]

  1. Calcoli KPI

total_sales = df["sales"].sum()
n_transactions = len(df)
avg_sales = df["sales"].mean()

  1. Aggregazioni

by_region = df.groupby("region")["sales"].sum().reset_index()
monthly = df.groupby([df["date"].dt.to_period("M"), "region"])["sales"].sum().unstack(fill_value=0)

  1. Crea grafico (come in Flask)

  • Usa Matplotlib per creare immagine PNG in memoria.

  1. Mostra tutto in Flask

  • Vedi esempio app.py sopra; per layout professionale, usa templates/index.html e passa le variabili (table_html, kpis).

Esempio di template con Jinja2 (templates/index.html)

<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <title>Dashboard Vendite</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    .kpi { display: inline-block; margin-right: 20px; padding: 10px; border: 1px solid #ddd; }
    .table { border-collapse: collapse; width: 50%; }
    .table th, .table td { border: 1px solid #ccc; padding: 6px; text-align: left; }
  </style>
</head>
<body>
  <h1>Dashboard Vendite</h1>
  <div>
    <div class="kpi"><strong>Vendite totali:</strong> {{ total_sales }}</div>
    <div class="kpi"><strong>Transazioni:</strong> {{ n_transactions }}</div>
    <div class="kpi"><strong>Vendita media:</strong> {{ avg_sales }}</div>
  </div>
  <h2>Riepilogo per regione</h2>
  {{ table_html | safe }}
  <h2>Grafico mensile</h2>
  <img src="/plot.png" alt="Grafico vendite">
</body>
</html>

In app.py usa render_template("index.html", ...) per passare variabili.

7) Consigli pratici e debugging

  • Per dataset grandi usa df.info() per capire tipi colonna e memoria.

  • Usare df.astype({"col":"category"}) per colonne categoriali riduce memoria.

  • Per grafici complessi considera Seaborn (built on Matplotlib) o Plotly (grafici interattivi).

  • In Flask, in sviluppo mantenere debug=True; in produzione usare WSGI server (gunicorn) e un web server (nginx).

8) Esempio completo minimo (file list)

  • sales.csv — dataset.

  • app.py — Flask example fornito sopra.

  • templates/index.html — template per la dashboard.

  • venv/ — ambiente virtuale.

Avvia:

python app.py

Apri http://127.0.0.1:5000/.

9) Esercizi proposti (da 30–60 min ciascuno)

A. Aggiungi nella dashboard un filtro per regione: selettore HTML che invia query string ?region=North e filtra dati lato server.
B. Aggiungi un histogram delle vendite per prodotto.
C. Esporta l’aggregato monthly in CSV e fornisci link per il download.
D. Sostituisci Matplotlib con Plotly per grafici interattivi (Plotly Express).

10) Risorse rapide / comandi utili

  • Visualizzare le prime righe: df.head()

  • Info dettagliate: df.info()

  • Statistiche descrittive: df.describe()

  • Raggruppare: df.groupby([...]).agg(...)

  • Salvare figura: fig.savefig("nome.png", dpi=150)

  • Flask: render_template, send_file, request.args.get("param")


alle
Etichette: ,

Nessun commento:

Posta un commento

Iscriviti a: Commenti sul post (Atom)

Corso Fondamenti di Informatica e Reti: 6 Reti di computer e Internet

Reti di computer e Internet Introduzione Prova a pensare alla vita quotidiana senza reti informatiche: niente messaggi WhatsApp, niente m...