Introduzione
Le librerie standard di Python sono uno dei motivi per cui il linguaggio è così produttivo: non serve installare pacchetti esterni per svolgere molte attività comuni. Tra le più utili troviamo math, datetime e random, tre moduli che spesso compaiono in progetti reali per calcoli, gestione del tempo e simulazioni.
In questo tutorial vedremo un caso pratico e realistico: generare un report automatico di attività giornaliere. L’obiettivo è simulare una piccola dashboard testuale che produce dati fittizi ma coerenti, ad esempio:
- durata di alcune attività in minuti,
- calcolo di ore totali e percentuali,
- data e ora di generazione del report,
- scelta casuale di un livello di priorità o stato.
Questo esempio è utile perché combina i tre moduli in modo naturale: random per creare dati variabili, datetime per gestire la data del report, e math per fare arrotondamenti e calcoli più puliti.
Codice completo
from datetime import datetime, timedelta
import math
import random
# -----------------------------
# Configurazione del report
# -----------------------------
attivita = [
"Email",
"Sviluppo",
"Riunione",
"Analisi dati",
"Documentazione"
]
priorita_possibili = ["Bassa", "Media", "Alta"]
# -----------------------------
# Generazione dati casuali
# -----------------------------
dati_attivita = []
for nome in attivita:
minuti = random.randint(15, 180) # durata casuale tra 15 e 180 minuti
priorita = random.choice(priorita_possibili)
dati_attivita.append({
"nome": nome,
"minuti": minuti,
"priorita": priorita
})
# -----------------------------
# Calcoli sul tempo totale
# -----------------------------
totale_minuti = sum(item["minuti"] for item in dati_attivita)
totale_ore = totale_minuti / 60
# Arrotondiamo in modo leggibile
totale_ore_rounded = math.ceil(totale_ore * 100) / 100
# -----------------------------
# Data e ora del report
# -----------------------------
ora_report = datetime.now()
scadenza_report = ora_report + timedelta(days=7)
# -----------------------------
# Calcolo percentuali per ogni attività
# -----------------------------
for item in dati_attivita:
percentuale = (item["minuti"] / totale_minuti) * 100
item["percentuale"] = round(percentuale, 1)
# -----------------------------
# Output del report
# -----------------------------
print("=" * 50)
print("REPORT AUTOMATICO DI ATTIVITÀ")
print("=" * 50)
print(f"Generato il: {ora_report.strftime(´%d/%m/%Y alle %H:%M:%S´)}")
print(f"Scadenza consigliata: {scadenza_report.strftime(´%d/%m/%Y´)}")
print(f"Tempo totale registrato: {totale_minuti} minuti ({totale_ore_rounded} ore)")
print()
for item in dati_attivita:
ore = item["minuti"] // 60
minuti_residui = item["minuti"] % 60
print(f"- {item[´nome´]}")
print(f" Priorità: {item[´priorita´]}")
print(f" Durata: {ore}h {minuti_residui}m")
print(f" Peso sul totale: {item[´percentuale´]}%")
print()
# Calcolo di una stima finale: se il totale supera 6 ore, segnaliamo un carico alto
if totale_ore > 6:
print("ATTENZIONE: carico di lavoro elevato.")
else:
print("Carico di lavoro nella norma.")Spiegazione
Vediamo il codice pezzo per pezzo, così da capire non solo cosa fa, ma anche perché è costruito in questo modo.
1. Import delle librerie
All’inizio importiamo:
- datetime e timedelta dal modulo datetime, per gestire data e intervalli temporali;
- math, per usare funzioni matematiche come
ceil(); - random, per generare valori casuali.
Questa separazione rende il codice chiaro e facile da leggere.
2. Definizione delle attività
La lista attivita contiene i nomi delle attività da includere nel report. È una struttura semplice ma molto pratica: in un progetto reale potrebbe arrivare da un database, da un file JSON o da un input utente.
Inoltre definiamo priorita_possibili, una lista da cui estrarre casualmente il livello di priorità di ogni attività.
3. Generazione dei dati casuali
Il ciclo for crea una lista di dizionari chiamata dati_attivita. Per ogni attività:
random.randint(15, 180)genera una durata casuale in minuti;random.choice(priorita_possibili)sceglie una priorità casuale.
Il risultato è una struttura dati ordinata e facile da elaborare in seguito.
4. Calcolo del totale
Con sum() sommiamo tutti i minuti delle attività. Poi li convertiamo in ore dividendo per 60.
Qui entra in gioco math: usiamo math.ceil() per arrotondare in modo controllato il totale delle ore. Questo può essere utile quando vuoi presentare un valore leggibile, ad esempio in un report manageriale o in una dashboard.
5. Uso di datetime
datetime.now() restituisce data e ora correnti. Questo è perfetto per registrare quando è stato generato il report.
Con timedelta(days=7) calcoliamo una scadenza consigliata a una settimana di distanza. È un esempio molto comune: pianificazione, reminder, scadenze, follow-up.
6. Percentuali per ogni attività
Per ogni attività calcoliamo il peso percentuale rispetto al totale. La formula è semplice:
(minuti attività / minuti totali) * 100
Il risultato viene arrotondato a una cifra decimale con round(..., 1), così il report resta leggibile.
7. Formattazione dell’output
Usiamo strftime() per formattare la data in modo umano, ad esempio gg/mm/aaaa. Questo è importante perché la rappresentazione standard di Python non sempre è la più adatta per l’utente finale.
Infine stampiamo un messaggio di avviso se il carico totale supera 6 ore. È una logica semplice, ma mostra come i dati generati possano essere usati per prendere decisioni automatiche.
Best practice
Quando usi le librerie standard in progetti reali, conviene seguire alcune buone pratiche:
- Usa nomi chiari per variabili e liste: nel codice,
dati_attivitaè più leggibile didataox. - Separa i dati dalla logica: prima generi o carichi i dati, poi li elabori, infine li mostri.
- Evita calcoli ripetuti: se un valore come il totale minuti serve più volte, calcolalo una sola volta.
- Formatta sempre date e numeri per l’output finale: migliora molto la leggibilità.
- Usa random con criterio: per test e simulazioni va benissimo, ma non per dati critici o sicurezza.
- Gestisci i casi limite: per esempio, se la lista delle attività fosse vuota, il calcolo delle percentuali causerebbe errori.
Un miglioramento utile sarebbe introdurre un controllo iniziale:
if not dati_attivita:
print("Nessuna attività disponibile.")
exit()Questo rende il programma più robusto.
Riepilogo
In questo tutorial abbiamo visto come combinare math, datetime e random per creare un report automatico di attività giornaliere. Il risultato è un esempio pratico che mostra tre abilità fondamentali:
- generare dati casuali realistici con random;
- gestire date e intervalli temporali con datetime;
- fare calcoli e arrotondamenti con math.
Queste librerie sono piccole ma potentissime. Saperle usare bene ti permette di scrivere script utili, test veloci e prototipi professionali senza dipendenze esterne.
Approfondisci con risorse ufficiali
- math: documentazione ufficiale Python — funzioni matematiche, arrotondamenti e costanti.
- datetime: documentazione ufficiale Python — gestione di date, orari e intervalli.
- random: documentazione ufficiale Python — numeri casuali, scelte casuali e simulazioni.
Per approfondire davvero, ti consiglio di provare a modificare l’esempio: aggiungi nuove attività, cambia la soglia di avviso, oppure salva il report su file. È il modo migliore per trasformare una demo in uno strumento riutilizzabile.