Python Academy · Lezione

Transazioni e context manager

Eseguire commit e rollback in sicurezza

Transazioni e context manager è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Che cos'è una transazione

Una transazione raggruppa diverse istruzioni, in modo che abbiano tutte successo oppure falliscano tutte insieme. In questo modo i dati restano coerenti.

SQLite avvia automaticamente una transazione prima delle istruzioni che modificano i dati.

import sqlite3
conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
print('Table ready for transactions')
conn.close()

Eseguire il commit per salvare

Le modifiche non diventano permanenti finché non chiama conn.commit(). Fino a quel momento esistono solo nella transazione corrente.

import sqlite3
conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
cur.execute('INSERT INTO accounts (balance) VALUES (100)')
conn.commit()
print('Committed')
conn.close()

Eseguire il rollback

conn.rollback() annulla tutte le modifiche effettuate dall'ultimo commit. Lo utilizzi quando qualcosa va storto.

import sqlite3
conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
conn.commit()
cur.execute('INSERT INTO accounts (balance) VALUES (100)')
conn.rollback()
cur.execute('SELECT COUNT(*) FROM accounts')
print('Rows after rollback:', cur.fetchone()[0])
conn.close()

Un trasferimento di denaro

Le transazioni sono particolarmente utili quando più aggiornamenti devono restare sincronizzati. Un bonifico sottrae denaro da un conto e lo aggiunge a un altro. Devono verificarsi entrambe le operazioni oppure nessuna delle due.

import sqlite3
conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
cur.execute('INSERT INTO accounts (id, balance) VALUES (1, 100)')
cur.execute('INSERT INTO accounts (id, balance) VALUES (2, 50)')
cur.execute('UPDATE accounts SET balance = balance - 30 WHERE id = 1')
cur.execute('UPDATE accounts SET balance = balance + 30 WHERE id = 2')
conn.commit()
cur.execute('SELECT id, balance FROM accounts')
print(cur.fetchall())
conn.close()

Gestire gli errori con try/except

Racchiuda una transazione in try/except. In caso di errore, esegua il rollback per evitare che modifiche parziali danneggino i dati.

import sqlite3
conn = sqlite3.connect(':memory:')
cur = conn.cursor()
cur.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
try:
    cur.execute('INSERT INTO accounts (id, balance) VALUES (1, 100)')
    cur.execute('INSERT INTO accounts (id, balance) VALUES (1, 200)')
    conn.commit()
except sqlite3.IntegrityError:
    conn.rollback()
    print('Rolled back after error')
conn.close()

La connessione come gestore di contesto

Utilizzando with conn:, il commit viene eseguito automaticamente in caso di successo e il rollback se all'interno del blocco si verifica un'eccezione.

import sqlite3
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY, balance INTEGER)')
with conn:
    conn.execute('INSERT INTO accounts (balance) VALUES (100)')
print('Auto-committed via with block')
conn.close()

Rollback automatico in caso di eccezione

Se il blocco with conn: genera un'eccezione, la transazione viene sottoposta automaticamente a rollback. Noti che la connessione rimane aperta.

import sqlite3
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE accounts (id INTEGER PRIMARY KEY)')
try:
    with conn:
        conn.execute('INSERT INTO accounts (id) VALUES (1)')
        conn.execute('INSERT INTO accounts (id) VALUES (1)')
except sqlite3.IntegrityError:
    print('Block rolled back automatically')
count = conn.execute('SELECT COUNT(*) FROM accounts').fetchone()[0]
print('Rows:', count)
conn.close()

closing() per la connessione

L'helper contextlib.closing garantisce che close() venga chiamato al termine del blocco, liberando la connessione.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(':memory:')) as conn:
    conn.execute('CREATE TABLE t (id INTEGER)')
    print('Used inside closing()')
print('Connection closed automatically')

Combinare entrambi gli approcci

Inserisca with conn: all'interno di closing(...) per gestire la transazione e garantire la chiusura della connessione.

import sqlite3
from contextlib import closing
with closing(sqlite3.connect(':memory:')) as conn:
    conn.execute('CREATE TABLE t (id INTEGER, v TEXT)')
    with conn:
        conn.execute('INSERT INTO t VALUES (1, ?)', ('hello',))
    print(conn.execute('SELECT * FROM t').fetchall())

isolation_level

isolation_level della connessione controlla quando iniziano le transazioni. Il valore predefinito lascia che sia SQLite a gestirle; impostandolo su None si abilita la modalità autocommit.

import sqlite3
conn = sqlite3.connect(':memory:')
print('Default isolation_level:', repr(conn.isolation_level))
conn.isolation_level = None
print('Now autocommit:', conn.isolation_level)
conn.close()

Perché le transazioni sono importanti

Senza transazioni, un arresto anomalo durante un aggiornamento potrebbe lasciare dati modificati solo a metà. Le transazioni rendono atomico, cioè indivisibile, un insieme di modifiche. In questo modo proteggono l'integrità dei dati.

import sqlite3
conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE log (msg TEXT)')
with conn:
    conn.execute('INSERT INTO log VALUES (?)', ('all or nothing',))
print('Atomic write done')
conn.close()

Verifica rapida

Verifichi la Sua conoscenza delle transazioni.

Riepilogo

Ha imparato a gestire le transazioni in modo sicuro.

commit() salva le modifiche; rollback() le annulla
Racchiuda le scritture rischiose in try/except con rollback
with conn: esegue automaticamente il commit o il rollback
contextlib.closing garantisce la chiusura della connessione

Domande Frequenti

La lezione «Transazioni e context manager» è gratuita?

Sì — il testo completo di «Transazioni e context manager» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Transazioni e context manager»?

Eseguire commit e rollback in sicurezza Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Transazioni e context manager»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy