Python Academy · Lektion

Transaktioner och kontexthanterare

Bekräfta och återställ säkert

Lektion 4 av 413 steg

Transaktioner och kontexthanterare är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad är en transaktion?

En transaktion grupperar flera satser så att de antingen lyckas allihop eller misslyckas allihop. Det håller dina data konsekventa.

SQLite startar automatiskt en transaktion före satser som ändrar data.

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()

Spara med commit

Ändringar blir inte permanenta förrän du anropar conn.commit(). Fram till dess finns de bara i den aktuella transaktionen.

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()

Rulla tillbaka

conn.rollback() ångrar alla ändringar sedan den senaste commit-operationen. Använd den när något går fel.

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()

En penningöverföring

Transaktioner är särskilt användbara när flera uppdateringar måste hållas synkroniserade. En banköverföring drar av pengar från ett konto och lägger till dem på ett annat. Båda måste genomföras, eller inget av dem.

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()

Hantera fel med try/except

Kapsla in en transaktion i try/except. Vid fel rullar du tillbaka så att delvisa ändringar inte förstör dina data.

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()

Anslutningen som kontexthanterare

Om du använder with conn: genomförs en commit automatiskt vid framgång, och en rollback görs om ett undantag inträffar i blocket.

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()

Automatisk rollback vid undantag

Om with conn:-blocket utlöser ett undantag rullas transaktionen automatiskt tillbaka. Observera att själva anslutningen förblir öppen.

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() för anslutningen

Hjälpfunktionen contextlib.closing garanterar att close() anropas när blocket avslutas, så att anslutningen frigörs.

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')

Kombinera båda mönstren

Kapsla in with conn: i closing(...) för att både hantera transaktionen och säkerställa att anslutningen stängs.

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

Anslutningens isolation_level styr när transaktioner startar. Standardinställningen låter SQLite hantera detta; om du anger None aktiveras autocommit-läge.

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()

Varför transaktioner är viktiga

Utan transaktioner kan en krasch mitt under en uppdatering lämna efter sig halvfärdiga data. Transaktioner gör en uppsättning ändringar atomär: odelbar. Det skyddar dataintegriteten.

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()

Snabbtest

Testa dina kunskaper om transaktioner.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig att hantera transaktioner på ett säkert sätt.

commit() sparar ändringar; rollback() ångrar dem
Kapsla in riskfyllda skrivningar i try/except med rollback
with conn: genomför automatiskt en commit eller rollback
contextlib.closing garanterar att anslutningen stängs

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Transaktioner och kontexthanterare” gratis?

Ja – hela texten till ”Transaktioner och kontexthanterare” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Transaktioner och kontexthanterare”?

Bekräfta och återställ säkert Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Transaktioner och kontexthanterare”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy