Python e database SQLite e MySQL con codice SQL, archivio relazionale e operazioni CRUD di inserimento, lettura, modifica ed eliminazione dei dati.
Python e database: gestione dei dati con SQLite, MySQL, istruzioni SQL e operazioni CRUD nelle applicazioni scientifiche.

Python e database: SQLite, MySQL, SQL e operazioni CRUD

Manuale MEGISTONE · Informatica · Python · Applicazioni STEM

Classe seconda — Liceo scientifico, Scienze applicate · Python 3.13

Da file TXT, CSV e JSON a database strutturati: imparerai a creare tabelle, collegare Python a SQLite, applicare le quattro operazioni CRUD, interpretare errori e transazioni e realizzare un piccolo archivio scientifico. MySQL verrà presentato come alternativa client-server facoltativa.

Prerequisiti: variabili, funzioni, cicli, liste, dizionari, eccezioni e file (articoli B1.01–B1.06). Risultati attesi: scegliere quando utilizzare un DBMS; eseguire query parametrizzate; gestire connessioni e transazioni; leggere e analizzare misure. Confine: modello ER, normalizzazione, progettazione relazionale sistematica e SQL avanzato rimangono nel Blocco D.

15.1 — Dalla persistenza dei file ai database

Nel capitolo B1.06 abbiamo salvato misure in file TXT, CSV, JSON e binari. Questo approccio è utile per registrazioni sequenziali, esportazione e condivisione. Immaginiamo però un archivio con migliaia di misure: trovare una temperatura specifica, correggerla senza riscrivere tutto il file o consentire accessi coordinati diventa più difficile.

Un database organizza dati destinati a durare nel tempo; un DBMS è il software che permette di conservarli, interrogare e modificare in modo controllato. Un programma Python può chiedere al DBMS di trovare soltanto le righe necessarie. La ridondanza (ripetere informazioni) può produrre incoerenze, per esempio lo stesso esperimento scritto con nomi differenti.

Il DBMS offre strumenti per vincoli, transazioni e accessi concorrenti, ma non elimina automaticamente ogni errore: occorre progettare e validare. Un CSV resta preferibile quando serve un formato semplice, portabile e leggibile; SQLite è vantaggioso per piccole applicazioni che devono ricercare e aggiornare record. I server DBMS rispondono meglio a scenari multiutente più impegnativi.

Schema del passaggio da un file CSV a un database relazionale SQLite tramite Python, con importazione dei dati e interrogazione SQL.
Dal file CSV al database relazionale: Python importa i dati in SQLite, li organizza in tabelle e permette interrogazioni SQL.

15.2 — Che cos’è un database

Dato: «21,5»; informazione: «temperatura del laboratorio = 21,5 °C, misurata il 12 novembre». Il contesto rende interpretabile il valore.

Un database contiene dati organizzati secondo uno schema. In una tabella ogni riga è un record e ogni colonna è un campo/attributo. Il DBMS SQLite gestisce il database, mentre lo script Python è l’applicazione che dialoga con esso: non sono la stessa cosa.

id data temperatura luogo
1 2026-11-10 19.5 Aula
2 2026-11-11 20.0 Aula
3 2026-11-12 21.5 Laboratorio

La colonna id identifica univocamente ogni record ed è una chiave primaria. Due osservazioni possono avere lo stesso valore di temperatura ma non lo stesso identificativo.

15.3 — Introduzione ai database relazionali

Nel modello relazionale i dati sono rappresentati mediante relazioni, comunemente visualizzate come tabelle. Un record descrive un’osservazione; una chiave primaria individua univocamente ciascuna riga. NOT NULL, UNIQUE e CHECK sono esempi di vincoli che proteggono la qualità dei dati.

NULL significa valore sconosciuto o assente, non zero e non stringa vuota. In SQL il controllo di un valore mancante usa IS NULL, non = NULL. Tabelle diverse possono essere collegate tramite identificativi, ma qui ci concentriamo sull’uso operativo di una singola tabella: progettazione ER e normalizzazione saranno affrontate nel Blocco D.

15.4 — SQLite: caratteristiche e applicazioni

SQLite è un DBMS relazionale incorporato: il motore viene usato direttamente dal programma e normalmente memorizza il database in un file, per esempio laboratorio.db. Non occorre avviare un server separato. Le query SQL operano su tabelle, non sulla sintassi di un CSV.

Vantaggi: semplicità, portabilità, installazione minima, supporto alle transazioni e buona integrazione con Python. Limiti: scritture concorrenti regolate da blocchi e minore aderenza a scenari con numerosi client remoti; per questi possono essere più adatti DBMS client-server. SQLite può anche operare in memoria, con :memory:, per prove temporanee.

Una transazione raggruppa operazioni che possono essere confermate oppure annullate; ne vedremo l’impiego pratico.

15.5 — Il modulo sqlite3 di Python

La libreria standard Python include sqlite3. connect() apre una connessione, execute() invia SQL, fetchone() legge una riga, fetchmany(n) ne legge fino a n, fetchall() legge tutte le righe restanti. commit() conferma, rollback() annulla modifiche non confermate, close() rilascia la connessione.

Il cursor conserva lo stato di una query e permette di recuperare progressivamente i risultati. Connection.execute() è una scorciatoia che restituisce un cursor. Non è necessario creare esplicitamente un cursor per ogni query elementare.

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    conn.execute("CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL)")
    conn.execute("INSERT INTO misure (valore) VALUES (?)", (21.5,))
    conn.commit()
    cursor = conn.execute("SELECT valore FROM misure")
    print(cursor.fetchone()[0])
Output atteso

21.5

Attenzione: with sqlite3.connect(...) da solo gestisce il confine della transazione, non garantisce la chiusura della connessione. Per questo esempio usiamo contextlib.closing.

15.6 — Creazione di un database SQLite

pathlib costruisce percorsi indipendenti dal sistema operativo. Se l’esempio è salvato in uno script, Path(__file__).resolve().parent indica la cartella dello script; in una console interattiva si può usare Path.cwd().

from pathlib import Path
import sqlite3
from contextlib import closing

cartella = Path.cwd() / "dati_esercizi"
cartella.mkdir(parents=True, exist_ok=True)
percorso = cartella / "laboratorio.db"
with closing(sqlite3.connect(percorso, autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE IF NOT EXISTS prove (id INTEGER PRIMARY KEY, nome TEXT NOT NULL)")
print(percorso.name)
Output atteso

laboratorio.db

IF NOT EXISTS evita l’errore se la tabella è già presente, ma non aggiorna automaticamente uno schema precedente. Per un esercizio che non lascia file, sostituisci il percorso con ":memory:".

Schema del collegamento tra Python e SQLite con creazione del database scuola.db, definizione della tabella studenti, chiave primaria e gestione della connessione.
SQLite in Python: dalla connessione al database alla creazione delle tabelle, con definizione dei campi, chiave primaria, salvataggio e chiusura.

15.7 — Linguaggio SQL: istruzioni fondamentali

SQL (Structured Query Language) è il linguaggio usato per definire e interrogare dati relazionali. Python gestisce input e logica del programma; SQL descrive l’operazione sul database. DDL comprende comandi come CREATE TABLE; DML comprende INSERT, UPDATE e DELETE. SELECT è la query di lettura, spesso classificata come DQL.

CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL NOT NULL);
INSERT INTO misure (valore) VALUES (20.5);
SELECT id, valore FROM misure WHERE valore >= 20 ORDER BY valore DESC LIMIT 5;
UPDATE misure SET valore = 21 WHERE id = 1;
DELETE FROM misure WHERE id = 1;

Le clausole WHERE, ORDER BY e LIMIT filtrano, ordinano e limitano i risultati. L’ordine dei comandi mostrato è didattico: una query agisce sullo stato corrente della tabella.

15.8 — Creazione e struttura delle tabelle

SQLite usa affinità di tipo, un sistema più flessibile di quello adottato da molti DBMS. Le principali classi di memorizzazione sono NULL, INTEGER, REAL, TEXT, BLOB. L’affinità suggerisce come interpretare e convertire valori: in una normale tabella SQLite il tipo dichiarato non impone sempre una tipizzazione rigida; esistono anche tabelle STRICT con regole più restrittive.

CREATE TABLE esperimenti (
    id INTEGER PRIMARY KEY,
    titolo TEXT NOT NULL UNIQUE,
    temperatura REAL CHECK (temperatura BETWEEN -273.15 AND 1000),
    descrizione TEXT
);

In SQLite una colonna INTEGER PRIMARY KEY (in una normale tabella rowid) è un alias del rowid e può ottenere un identificativo automaticamente. AUTOINCREMENT è opzionale, ha semantica più specifica e non va aggiunto indiscriminatamente. Il vincolo CHECK non è un sostituto della validazione applicativa; inoltre l’esempio permette NULL nella temperatura, perché manca NOT NULL.

15.9 — CREATE: inserire dati nel database

La C di CRUD significa Create, cioè inserire record; non va confusa con il comando SQL CREATE TABLE, che crea la struttura della tabella. I dati esterni passano sempre attraverso parametri SQL, non tramite concatenazione di stringhe.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE dati (id INTEGER PRIMARY KEY, valore REAL NOT NULL)")
        primo = conn.execute("INSERT INTO dati(valore) VALUES (?)", (19.5,))
        print("ID:", primo.lastrowid)
        conn.executemany("INSERT INTO dati(valore) VALUES (?)", [(20.0,), (21.5,)])
    print("Righe:", conn.execute("SELECT COUNT(*) FROM dati").fetchone()[0])
Output atteso

ID: 1
Righe: 3

Nella tupla (19.5,) la virgola è necessaria: crea una sequenza con un solo elemento. executemany() invia la stessa istruzione per più gruppi di parametri. Se il valore non è valido, rifiutalo prima di inserirlo; i vincoli SQL rimangono una seconda linea di difesa.

15.10 — READ: interrogare il database

La R di CRUD corrisponde a Read. Con SELECT scegli colonne, condizioni e ordinamento. Un risultato vuoto non è un errore: fetchone() restituisce None se non ci sono righe, mentre fetchall() restituisce una lista vuota.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    conn.row_factory = sqlite3.Row
    with conn:
        conn.execute("CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL)")
        conn.executemany("INSERT INTO misure(valore) VALUES (?)", [(19.5,), (21.5,)])
    righe = conn.execute("SELECT id, valore FROM misure WHERE valore > ? ORDER BY valore", (20,)).fetchall()
    for riga in righe:
        print(riga["id"], f"{riga['valore']:.2f}")
    print("Assente:", conn.execute("SELECT * FROM misure WHERE id = ?", (99,)).fetchone())
Output atteso

2 21.50
Assente: None

In modalità predefinita ogni riga letta è una tupla; con sqlite3.Row si può accedere per nome come riga["valore"], ma Row non è esattamente un dizionario. Con dict(riga) si ottiene un vero dizionario. fetchmany(10) è utile per letture a blocchi.

15.11 — UPDATE: modificare i dati

La U significa Update: modifica un record già esistente. Prima di cambiare una misura verifica identificativo e valore. Una UPDATE priva di una condizione adeguata può cambiare tutte le righe: è un errore grave in un archivio reale.

# Con conn già aperta e tabella misure creata:
with conn:
    risultato = conn.execute(
        "UPDATE misure SET valore = ? WHERE id = ?", (20.25, 1)
    )
    print("Record modificati:", risultato.rowcount)

rowcount indica quante righe sono state interessate dall’istruzione. Se vale zero, l’identificativo potrebbe non esistere. Nell’applicazione completa la funzione aggiorna() implementa questo controllo e conferma all’utente l’esito.

15.12 — DELETE: eliminare i record

La D significa Delete. DELETE FROM misure WHERE id = ? elimina una riga, mentre cancellare il file .db significa eliminare l’intero database, operazione completamente diversa. Una DELETE senza WHERE può eliminare tutte le righe.

# Su un database di esercitazione, con conn già aperta:
with conn:
    cancellati = conn.execute("DELETE FROM misure WHERE id = ?", (2,)).rowcount
    print("Eliminati:", cancellati)

Il programma MEGI richiede una conferma esplicita prima della cancellazione. Finché le modifiche non sono state confermate, un rollback può annullarle; dopo il commit non si può contare sul rollback per ricostruire i dati. Per questo servono backup e controlli.

Infografica delle quattro operazioni CRUD con Python e SQLite: inserimento, lettura, aggiornamento ed eliminazione dei record mediante istruzioni SQL.
Operazioni CRUD con Python e SQLite: inserire nuovi record con INSERT, interrogare i dati con SELECT, modificarli con UPDATE ed eliminarli con DELETE.

15.13 — Gestione delle transazioni e degli errori

Le proprietà ACID descrivono, a livello introduttivo, atomicità (tutto o niente), consistenza (vincoli rispettati), isolamento (coordinamento tra transazioni) e durabilità (persistenza dopo conferma). sqlite3.IntegrityError segnala per esempio un vincolo violato; sqlite3.OperationalError può riguardare una tabella mancante o un blocco; entrambe derivano da sqlite3.Error.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    conn.execute("CREATE TABLE voci (id INTEGER PRIMARY KEY, nome TEXT UNIQUE)")
    conn.commit()
    try:
        with conn:
            conn.execute("INSERT INTO voci(nome) VALUES (?)", ("A",))
            conn.execute("INSERT INTO voci(nome) VALUES (?)", ("A",))
    except sqlite3.IntegrityError:
        print("Vincolo violato: transazione annullata")
    print("Righe rimaste:", conn.execute("SELECT COUNT(*) FROM voci").fetchone()[0])
Output atteso

Vincolo violato: transazione annullata
Righe rimaste: 0

Python 3.13: si raccomanda il controllo delle transazioni mediante il parametro autocommit. Con autocommit=False Python mantiene aperta una transazione e commit()/rollback() funzionano. Con autocommit=True quei metodi non producono lo stesso effetto; in modalità LEGACY_TRANSACTION_CONTROL il comportamento dipende anche da isolation_level. Il default di Python 3.13 è ancora la modalità legacy, quindi in questi esempi la scelta viene dichiarata esplicitamente. Il gestore with conn: conferma alla fine del blocco senza eccezioni e annulla in caso di errore, ma non chiude la connessione.

15.14 — Sicurezza e correttezza delle query SQL

Una query SQL non deve incorporare direttamente testo digitato dall’utente. La concatenazione ingenua di input e comando può alterare il significato dell’istruzione (SQL injection). I placeholder trattano i valori come dati anziché come codice SQL.

nome = input("Titolo da cercare: ")
righe = conn.execute("SELECT * FROM esperimenti WHERE titolo = ?", (nome,)).fetchall()
# Alternativa con parametro nominato:
righe = conn.execute("SELECT * FROM esperimenti WHERE titolo = :titolo", {"titolo": nome}).fetchall()

Non si possono usare placeholder per sostituire il nome di una tabella o colonna: quando gli identificatori sono dinamici, selezionarli da un insieme fisso di nomi consentiti. Validare tipo, intervallo, lunghezza e formato dei valori; proteggere i file database, eseguire backup, concedere soltanto i privilegi necessari. I dati personali richiedono cautela aggiuntiva.

15.15 — MySQL e collegamento con Python

MySQL è un DBMS relazionale generalmente usato in architettura client-server: Python si collega a un servizio che può risiedere su un altro computer. Per la connessione occorrono normalmente host, porta (spesso 3306), nome del database, utente, password e un driver esterno. SQLite, invece, è incorporato e il progetto principale non richiede MySQL.

Un esempio facoltativo usa mysql-connector-python, il connettore ufficiale della famiglia 9.x con supporto documentato a Python 3.13. Installazione in un ambiente virtuale: python -m pip install mysql-connector-python. Il codice seguente è illustrativo, non collaudato contro un server.

# Richiede un server MySQL di prova e mysql-connector-python.
import os
import mysql.connector

conn = mysql.connector.connect(
    host=os.environ["MEGI_MYSQL_HOST"],
    port=3306,
    user=os.environ["MEGI_MYSQL_USER"],
    password=os.environ["MEGI_MYSQL_PASSWORD"],
    database=os.environ["MEGI_MYSQL_DATABASE"],
)
try:
    cur = conn.cursor()
    cur.execute("SELECT id, titolo FROM esperimenti WHERE id = %s", (1,))
    print(cur.fetchall())
    conn.commit()
except mysql.connector.Error:
    conn.rollback()
    raise
finally:
    cur.close() if 'cur' in locals() else None
    conn.close()

Il placeholder %s del driver MySQL non coincide con ? di SQLite. Non salvare credenziali reali nel sorgente. Per un progetto di produzione servono anche configurazione TLS, privilegi minimi e politiche adeguate di gestione dei segreti.

15.16 — Applicazioni STEM con database

Esperimento A — Archivio delle temperature

Problema: archiviare tre misure, correggere l’ultima e calcolare numero di osservazioni, media, minimo e massimo. Dati iniziali: 19,5; 20,0; 21,5 °C. Algoritmo: crea tabella → inserisci → correggi per ID → interroga con funzioni di aggregazione → interpreta.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE temperature (id INTEGER PRIMARY KEY, giorno TEXT, gradi REAL NOT NULL)")
        conn.executemany("INSERT INTO temperature(giorno, gradi) VALUES (?, ?)", [
            ("2026-11-10", 19.5), ("2026-11-11", 20.0), ("2026-11-12", 21.5)])
    with conn:
        conn.execute("UPDATE temperature SET gradi = ? WHERE id = ?", (21.0, 3))
    n, media, minimo, massimo = conn.execute(
        "SELECT COUNT(*), AVG(gradi), MIN(gradi), MAX(gradi) FROM temperature").fetchone()
    print(f"n={n}; media={media:.2f} °C; min={minimo:.2f} °C; max={massimo:.2f} °C")
Output atteso

n=3; media=20.17 °C; min=19.50 °C; max=21.00 °C

Interpretazione: dopo la correzione la media aritmetica è 20,17 °C. Casi limite: tabella vuota (AVG restituisce NULL), valori non numerici, misure con unità diverse e correzione di ID inesistenti. La media non esprime incertezza strumentale.

Esperimento B — Catalogo degli esperimenti

Problema: catalogare un’esperienza con titolo, data, descrizione e stato; realizzare tutte le operazioni CRUD. Dati iniziali: «Pendolo», 2026-11-17, «Periodo e lunghezza», aperto. Algoritmo: creare la tabella, inserire, leggere con SELECT, aggiornare lo stato, leggere e cancellare in modo controllato.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("""CREATE TABLE esperimenti (id INTEGER PRIMARY KEY,
            titolo TEXT NOT NULL, data TEXT NOT NULL, descrizione TEXT, stato TEXT NOT NULL)""")
        conn.execute("INSERT INTO esperimenti(titolo,data,descrizione,stato) VALUES (?,?,?,?)",
                     ("Pendolo", "2026-11-17", "Periodo e lunghezza", "aperto"))
    print("Creati:", conn.execute("SELECT COUNT(*) FROM esperimenti").fetchone()[0])
    with conn:
        conn.execute("UPDATE esperimenti SET stato=? WHERE id=?", ("completato", 1))
    print("Stato:", conn.execute("SELECT stato FROM esperimenti WHERE id=?", (1,)).fetchone()[0])
    with conn:
        conn.execute("DELETE FROM esperimenti WHERE id=?", (1,))
    print("Residui:", conn.execute("SELECT COUNT(*) FROM esperimenti").fetchone()[0])
Output atteso

Creati: 1
Stato: completato
Residui: 0

Interpretazione: l’identificativo non cambia durante UPDATE; DELETE elimina il record ma non la struttura. Casi limite: titoli vuoti, stati non ammessi e record assenti. In una versione più rigorosa prevedere CHECK(stato IN (...)).

Esperimento C — Dal CSV al database

Problema: importare tre righe CSV, scartando una misura non numerica. Dati iniziali: 19,5; «errore»; 21,5 °C. Algoritmo: leggere con csv.DictReader, validare, accumulare righe valide, usare executemany(), confrontare i risultati.

import csv, io, sqlite3
from contextlib import closing
origine = io.StringIO("giorno,gradi\n2026-11-10,19.5\n2026-11-11,errore\n2026-11-12,21.5\n")
validi, scartati = [], 0
for r in csv.DictReader(origine):
    try:
        valore = float(r["gradi"])
        if not -273.15 <= valore <= 1000:
            raise ValueError("Temperatura fuori intervallo")
        validi.append((r["giorno"], valore))
    except (ValueError, TypeError):
        scartati += 1
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE temperature (giorno TEXT, gradi REAL)")
        conn.executemany("INSERT INTO temperature VALUES (?, ?)", validi)
    n, media = conn.execute("SELECT COUNT(*), AVG(gradi) FROM temperature").fetchone()
    print(f"CSV: 3 righe; valide: {len(validi)}; scartate: {scartati}")
    print(f"Database: {n} righe; media: {media:.2f} °C")
Output atteso

CSV: 3 righe; valide: 2; scartate: 1
Database: 2 righe; media: 20.50 °C

Interpretazione: i dati nel database sono un sottoinsieme validato dell’input; non dobbiamo nascondere gli scarti. Casi limite: intestazioni mancanti, CSV vuoto, separatore diverso, codifica e valori non finiti (nan, inf); il programma scaricabile esegue controlli ulteriori.

Infografica su database scientifici con Python e SQLite: query SQL, transazioni COMMIT e ROLLBACK, gestione degli errori e analisi delle temperature.
Database scientifici con Python e SQLite: interrogazioni SQL, transazioni sicure, gestione delle eccezioni e analisi di misure sperimentali con AVG e MAX.

15.17 — Progetto Python STEM scaricabile

MEGI — Gestore di database scientifici Python è un’applicazione da terminale che usa esclusivamente librerie standard e un database SQLite in una sottocartella dati. Le funzioni sono separate: inizializzazione, inserimento, ricerca, aggiornamento, eliminazione con conferma, analisi statistica, importazione CSV e dati campione.

Avvia il file MEGI_Gestore_Database_Scientifici.py con IDLE (F5) o da VS Code/terminale con python MEGI_Gestore_Database_Scientifici.py. Seleziona 1 per caricare i tre campioni, 3 per leggerli e 7 per ottenere media/min/max. Il caricamento dei campioni funziona soltanto quando la tabella è vuota: non sovrascrive registrazioni esistenti.

SCARICA IL PROGETTO PYTHON STEM

Programma Python autonomo con SQLite, esempi scientifici e README.

1 Campioni | 2 Inserisci | 3 Elenca | 4 Cerca | 5 Aggiorna | 6 Elimina | 7 Analisi | 8 Importa CSV | 0 Esci
Scelta: 1
Campioni caricati: 3
Scelta: 7
Grandezza (vuoto = tutte): Temperatura
N=3; media=20.33; min=19.50; max=21.50

Il pacchetto ZIP scaricabile contiene il programma Python autonomo, un database SQLite di esempio, un file CSV con dati campione e il README con le istruzioni per l’esecuzione.
Il progetto utilizza esclusivamente librerie standard di Python e non richiede MySQL.

15.18 — Allenati con MEGI — 20 esercizi progressivi

Gli esercizi sono ordinati in cinque livelli (A–E), quattro per ciascuno. Ogni soluzione è nascosta inizialmente e si apre individualmente per l’autocorrezione. Negli esercizi 13–17 il codice Python 3.13 è autonomo e usa database SQLite temporanei: non modifica archivi personali.

Livello A — Comprensione

Esercizio 01 — Spiega quando preferire CSV a SQLite.

Obiettivo: Spiega quando preferire CSV a SQLite.

Traccia: Raffronta esportazione semplice e aggiornamento selettivo.

Mostra soluzione commentata — esercizio 01

CSV è ottimo per scambiare una tabella piatta; SQLite è adatto a interrogazioni e aggiornamenti ripetuti con transazioni.

Risultato atteso: Distinguere esigenze, non affermare che uno sia sempre superiore.

Esercizio 02 — Distingui database, DBMS e applicazione.

Obiettivo: Distingui database, DBMS e applicazione.

Traccia: Definisci i tre termini in una frase ciascuno.

Mostra soluzione commentata — esercizio 02

Database: insieme organizzato dei dati; DBMS: sistema di gestione; applicazione Python: programma che li utilizza.

Risultato atteso: Tre ruoli distinti.

Esercizio 03 — Chiave primaria e NULL.

Obiettivo: Chiave primaria e NULL.

Traccia: Perché servono? NULL equivale a zero?

Mostra soluzione commentata — esercizio 03

Una chiave primaria distingue record; NULL denota un valore mancante/sconosciuto, non zero.

Risultato atteso: Mai confrontare NULL con = NULL.

Esercizio 04 — Descrivi CRUD.

Obiettivo: Descrivi CRUD.

Traccia: Collega le quattro lettere alle istruzioni più comuni.

Mostra soluzione commentata — esercizio 04

Create → INSERT; Read → SELECT; Update → UPDATE; Delete → DELETE.

Risultato atteso: CREATE TABLE definisce la struttura, non è la C operativa di CRUD.

Livello B — Lettura e tracciamento

Esercizio 05 — Conta i risultati di una SELECT.

Obiettivo: Conta i risultati di una SELECT.

Traccia: Dati 10, 15, 20: quante righe soddisfano valore > 12?

Mostra soluzione commentata — esercizio 05

Due righe: 15 e 20.

Risultato atteso: 2

Esercizio 06 — Comprendi fetchone().

Obiettivo: Comprendi fetchone().

Traccia: Cosa restituisce una SELECT senza risultati?

Mostra soluzione commentata — esercizio 06

fetchone() restituisce None; fetchall() restituisce [].

Risultato atteso: None oppure [] secondo il metodo.

Esercizio 07 — Prevedi rowcount.

Obiettivo: Prevedi rowcount.

Traccia: UPDATE di id=99 su tabella che contiene soltanto id=1 e id=2.

Mostra soluzione commentata — esercizio 07

rowcount sarà 0 perché nessun record corrisponde.

Risultato atteso: 0

Esercizio 08 — Prevedi AVG().

Obiettivo: Prevedi AVG().

Traccia: Tre valori 19.5, 20.0, 21.5: quale media?

Mostra soluzione commentata — esercizio 08

(19.5+20.0+21.5)/3 = 20.333…, mostrata come 20.33.

Risultato atteso: 20.33

Livello C — Debugging

Esercizio 09 — Correggi il parametro singolo.

Obiettivo: Correggi il parametro singolo.

Traccia: Trova l’errore in conn.execute(“SELECT * FROM t WHERE id=?”, (5)).

Mostra soluzione commentata — esercizio 09

Usa (5,) invece di (5): la virgola forma una tupla singola.

Risultato atteso: (5,)

Esercizio 10 — Correggi NULL.

Obiettivo: Correggi NULL.

Traccia: Perché WHERE nota = NULL non trova dati mancanti?

Mostra soluzione commentata — esercizio 10

Perché SQL usa una logica a tre valori: la verifica corretta è WHERE nota IS NULL.

Risultato atteso: IS NULL

Esercizio 11 — Proteggi una query.

Obiettivo: Proteggi una query.

Traccia: Sostituisci una query costruita concatenando una variabile.

Mostra soluzione commentata — esercizio 11

conn.execute(“SELECT * FROM t WHERE nome=?”, (nome,)) mantiene separati dati e SQL.

Risultato atteso: Placeholder ?

Esercizio 12 — Correggi il ciclo di vita.

Obiettivo: Correggi il ciclo di vita.

Traccia: Perché with sqlite3.connect(…) non assicura la chiusura?

Mostra soluzione commentata — esercizio 12

Il context manager della connessione gestisce commit/rollback. Usa contextlib.closing oppure conn.close() in finally.

Risultato atteso: Chiusura esplicita

Livello D — Programmazione SQLite

Esercizio 13 — Crea una tabella di misure.

Obiettivo: Crea una tabella di misure.

Traccia: Scrivi SQL per id intero primario e valore REAL obbligatorio.

Mostra soluzione commentata — esercizio 13

Soluzione Python 3.13 completa ed eseguibile (database di prova in memoria):

import sqlite3
from contextlib import closing

# Database isolato: nessun file personale modificato.
with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("""CREATE TABLE misure (
            id INTEGER PRIMARY KEY,
            valore REAL NOT NULL
        )""")
    presente = conn.execute("""SELECT name FROM sqlite_master
        WHERE type = 'table' AND name = ?""", ("misure",)).fetchone()
    print("Tabella creata:", presente[0])

Spiegazione: La definizione SQL è eseguita da Python; `PRIMARY KEY` identifica ogni riga e `NOT NULL` rende obbligatorio il valore.

Output verificato (Python 3.13.5)

Tabella creata: misure

Esercizio 14 — Inserisci con parametri.

Obiettivo: Inserisci con parametri.

Traccia: Prepara una INSERT sicura per 18.75.

Mostra soluzione commentata — esercizio 14

Soluzione Python 3.13 completa ed eseguibile (database di prova in memoria):

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL NOT NULL)")
        cursor = conn.execute(
            "INSERT INTO misure (valore) VALUES (?)", (18.75,)
        )
        identificativo = cursor.lastrowid
    valore = conn.execute(
        "SELECT valore FROM misure WHERE id = ?", (identificativo,)
    ).fetchone()[0]
    print(f"ID={identificativo}; valore={valore:.2f}")

Spiegazione: Il placeholder `?` separa dato e istruzione SQL; `(18.75,)` è una tupla con un solo elemento. Il blocco transazionale conferma l’inserimento.

Output verificato (Python 3.13.5)

ID=1; valore=18.75

Esercizio 15 — Ricerca ordinata.

Obiettivo: Ricerca ordinata.

Traccia: Elenca i cinque valori maggiori di 20 in ordine decrescente.

Mostra soluzione commentata — esercizio 15

Soluzione Python 3.13 completa ed eseguibile (database di prova in memoria):

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL NOT NULL)")
        conn.executemany("INSERT INTO misure (valore) VALUES (?)",
                         [(18.0,), (21.5,), (25.0,), (19.0,),
                          (23.0,), (30.0,), (22.0,), (27.0,)])
    righe = conn.execute("""SELECT valore FROM misure
        WHERE valore > ? ORDER BY valore DESC LIMIT 5""", (20.0,)).fetchall()
    print(", ".join(f"{r[0]:.2f}" for r in righe))

Spiegazione: `WHERE` esclude i valori fino a 20 inclusi, `ORDER BY … DESC` ordina dal maggiore e `LIMIT 5` mostra al massimo cinque righe.

Output verificato (Python 3.13.5)

30.00, 27.00, 25.00, 23.00, 22.00

Esercizio 16 — Elimina per ID.

Obiettivo: Elimina per ID.

Traccia: Elimina solo il record 3.

Mostra soluzione commentata — esercizio 16

Soluzione Python 3.13 completa ed eseguibile (database di prova in memoria):

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE misure (id INTEGER PRIMARY KEY, valore REAL NOT NULL)")
        conn.executemany("INSERT INTO misure (id, valore) VALUES (?, ?)",
                         [(1, 18.5), (2, 19.5), (3, 20.5)])
    id_da_eliminare = 3  # ID esplicito e preventivamente verificato
    esiste = conn.execute("SELECT 1 FROM misure WHERE id = ?",
                          (id_da_eliminare,)).fetchone() is not None
    eliminate = 0
    if esiste:
        with conn:
            cursor = conn.execute("DELETE FROM misure WHERE id = ?",
                                  (id_da_eliminare,))
            eliminate = cursor.rowcount
    rimaste = conn.execute("SELECT COUNT(*) FROM misure").fetchone()[0]
    print(f"Eliminate={eliminate}; rimaste={rimaste}")

Spiegazione: La cancellazione riguarda soltanto la chiave indicata ed è eseguita in un database temporaneo; si controllano esistenza e `rowcount`.

Output verificato (Python 3.13.5)

Eliminate=1; rimaste=2

Livello E — Applicazioni STEM

Esercizio 17 — Media delle temperature.

Obiettivo: Media delle temperature.

Traccia: Leggi media e minimo di una tabella di temperature.

Mostra soluzione commentata — esercizio 17

Soluzione Python 3.13 completa ed eseguibile (database di prova in memoria):

import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:", autocommit=False)) as conn:
    with conn:
        conn.execute("CREATE TABLE temperature (id INTEGER PRIMARY KEY, gradi REAL NOT NULL)")
        conn.executemany("INSERT INTO temperature (gradi) VALUES (?)",
                         [(19.5,), (20.0,), (21.5,)])
    media, minimo = conn.execute(
        "SELECT AVG(gradi), MIN(gradi) FROM temperature"
    ).fetchone()
    if media is None:
        print("Nessuna misura disponibile")
    else:
        print(f"Media={media:.2f} °C; minimo={minimo:.2f} °C")

Spiegazione: `AVG` e `MIN` restituiscono valori aggregati; su tabella vuota restituiscono `NULL` (in Python `None`), perciò il controllo è necessario prima della formattazione.

Output verificato (Python 3.13.5)

Media=20.33 °C; minimo=19.50 °C

Esercizio 18 — CSV con errore.

Obiettivo: CSV con errore.

Traccia: Un CSV contiene 19.5, x, 21.5: quante righe importi?

Mostra soluzione commentata — esercizio 18

Due valide, una scartata; media delle valide 20.50.

Risultato atteso: 2 valide; 1 scartata

Esercizio 19 — Controllo dei vincoli.

Obiettivo: Controllo dei vincoli.

Traccia: Una temperatura inferiore a -273.15 °C deve essere accettata?

Mostra soluzione commentata — esercizio 19

No: prevedi validazione applicativa e un CHECK coerente con il modello fisico.

Risultato atteso: Record rifiutato

Esercizio 20 — Transazione sicura.

Obiettivo: Transazione sicura.

Traccia: Due INSERT, la seconda viola UNIQUE: cosa accade con with conn e autocommit=False?

Mostra soluzione commentata — esercizio 20

Entrambe le modifiche della transazione vengono annullate se l’eccezione esce dal blocco with conn.

Risultato atteso: 0 nuove righe

Collegamenti e documentazione

Per ripassare: B1.05 — Collezioni Python e B1.06 — File Python e percorsi.

Documentazione tecnica: Python 3.13 — sqlite3; SQLite — Datatypes; MySQL Connector/Python.

Il pulsante arancione per il futuro MEGISTONE STEM LAB B1.07 andrà inserito soltanto dopo la pubblicazione e il collaudo del laboratorio. Analogamente, il pulsante download ZIP sarà collegato all’URL definitivo solo dopo l’upload.

Articoli simili