Python Academy · Lekcja

Transakcje i menedżery kontekstu

Bezpiecznie zatwierdzaj i wycofuj zmiany

Transakcje i menedżery kontekstu to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Czym jest transakcja?

Transakcja grupuje kilka instrukcji, dzięki czemu wszystkie kończą się powodzeniem albo wszystkie zostają wycofane. Zapewnia to spójność danych.

SQLite automatycznie rozpoczyna transakcję przed wykonaniem instrukcji zmieniających dane.

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

Zatwierdzanie zmian

Zmiany nie są trwałe, dopóki nie wywołasz conn.commit(). Do tego czasu istnieją tylko w bieżącej transakcji.

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

Wycofywanie zmian

conn.rollback() cofa wszystkie zmiany od ostatniego zatwierdzenia. Użyj go, gdy coś pójdzie nie tak.

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

Przelew pieniędzy

Transakcje są szczególnie przydatne, gdy wiele aktualizacji musi pozostać ze sobą zgodnych. Przelew bankowy odejmuje kwotę z jednego konta i dodaje ją do drugiego. Obie operacje muszą się wykonać albo nie może wykonać się żadna z nich.

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

Obsługa błędów za pomocą try/except

Umieść transakcję w bloku try/except. W razie błędu wycofaj zmiany, aby częściowe modyfikacje nie uszkodziły danych.

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

Połączenie jako menedżer kontekstu

Użycie with conn: automatycznie zatwierdza zmiany po pomyślnym wykonaniu bloku i wycofuje je, jeśli wewnątrz bloku wystąpi wyjątek.

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

Automatyczne wycofanie po wyjątku

Jeśli w bloku with conn: wystąpi wyjątek, transakcja zostanie automatycznie wycofana. Pamiętaj, że samo połączenie pozostanie otwarte.

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() dla połączenia

Pomocnicza funkcja contextlib.closing gwarantuje wywołanie close() po zakończeniu bloku, zwalniając połączenie.

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

Łączenie obu wzorców

Umieść with conn: wewnątrz closing(...), aby jednocześnie zarządzać transakcją i zagwarantować zamknięcie połączenia.

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

Właściwość isolation_level połączenia określa, kiedy rozpoczynają się transakcje. Wartość domyślna pozwala SQLite zarządzać nimi automatycznie, a ustawienie None włącza tryb automatycznego zatwierdzania.

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

Dlaczego transakcje są ważne

Bez transakcji awaria w trakcie aktualizacji mogłaby pozostawić dane w połowie zmienione. Transakcje sprawiają, że zestaw zmian jest atomowy, czyli niepodzielny. Chroni to integralność danych.

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

Szybki test

Sprawdź swoją wiedzę o transakcjach.

Podsumowanie

Nauczyłeś się bezpiecznie zarządzać transakcjami.

commit() zapisuje zmiany, a rollback() je cofa
Ryzykowne operacje zapisu umieszczaj w bloku try/except z wycofaniem zmian
with conn: automatycznie zatwierdza zmiany lub je wycofuje
contextlib.closing gwarantuje zamknięcie połączenia

Często zadawane pytania

Czy lekcja „Transakcje i menedżery kontekstu” jest bezpłatna?

Tak — pełny tekst „Transakcje i menedżery kontekstu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Transakcje i menedżery kontekstu”?

Bezpiecznie zatwierdzaj i wycofuj zmiany Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Transakcje i menedżery kontekstu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Python Academy