0Pricing
Python Academy · Aula

Transações e gerenciadores de contexto

Confirme e reverta transações com segurança

Transações e gerenciadores de contexto é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é uma transação

Uma transação agrupa várias instruções para que todas sejam concluídas ou todas falhem juntas. Isso mantém seus dados consistentes.

O SQLite inicia uma transação automaticamente antes de instruções que alteram dados.

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

Confirme para salvar

As alterações não são permanentes até que você chame conn.commit(). Até lá, elas existem apenas na transação atual.

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

Revertendo alterações

conn.rollback() desfaz todas as alterações desde a última confirmação. Use-o quando algo der errado.

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

Uma transferência de dinheiro

As transações são especialmente úteis quando várias atualizações precisam permanecer sincronizadas. Uma transferência bancária subtrai um valor de uma conta e adiciona-o a outra. Ambas as operações devem ocorrer ou nenhuma delas deve ocorrer.

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

Tratando erros com try/except

Coloque uma transação dentro de try/except. Em caso de erro, reverta as alterações para que mudanças parciais não corrompam seus dados.

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

A conexão como gerenciador de contexto

Usar with conn: confirma automaticamente a transação em caso de sucesso e a reverte se ocorrer uma exceção dentro do bloco.

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

Reversão automática em caso de exceção

Se o bloco with conn: gerar uma exceção, a transação será revertida automaticamente. Observe que a própria conexão continua aberta.

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() para a conexão

O recurso auxiliar contextlib.closing garante que close() seja chamado quando o bloco terminar, liberando a conexão.

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

Combinando os dois padrões

Aninhe with conn: dentro de closing(...) para gerenciar a transação e garantir que a conexão seja fechada.

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

Nível de isolamento

O isolation_level da conexão controla quando as transações começam. O padrão permite que o SQLite faça esse gerenciamento; defini-lo como None ativa o modo de confirmação automática.

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

Por que as transações são importantes

Sem transações, uma falha no meio de uma atualização poderia deixar dados parcialmente modificados. As transações tornam um conjunto de alterações atômico: indivisível. Isso protege a integridade.

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ção rápida

Teste seus conhecimentos sobre transações.

Recapitulação

Você aprendeu a gerenciar transações com segurança.

  • commit() salva as alterações; rollback() desfaz essas alterações
  • Coloque gravações arriscadas em try/except com reversão
  • with conn: confirma ou reverte automaticamente
  • contextlib.closing garante que a conexão seja fechada

Perguntas Frequentes

A aula “Transações e gerenciadores de contexto” é grátis?

Sim — o texto completo de “Transações e gerenciadores de contexto” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Transações e gerenciadores de contexto”?

Confirme e reverta transações com segurança Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Transações e gerenciadores de contexto”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Conexão e criação de tabelas
  2. Inserir, selecionar, atualizar e excluir
  3. Consultas parametrizadas
  4. Transações e gerenciadores de contexto
← Voltar para Python Academy