0Pricing
Python Academy · Lección

Transacciones y gestores de contexto

Confirme y revierta operaciones de forma segura

Transacciones y gestores de contexto es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Qué es una transacción?

Una transacción agrupa varias instrucciones para que todas se completen correctamente o fallen juntas. Esto mantiene la coherencia de los datos.

SQLite inicia una transacción automáticamente antes de las instrucciones que modifican datos.

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

Confirmar para guardar

Los cambios no son permanentes hasta que llama a conn.commit(). Hasta ese momento, solo existen en la transacción actual.

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

Revertir los cambios

conn.rollback() deshace todos los cambios realizados desde la última confirmación. Úselo cuando algo salga mal.

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

Una transferencia de dinero

Las transacciones son especialmente útiles cuando varias actualizaciones deben mantenerse sincronizadas. Una transferencia bancaria resta dinero de una cuenta y lo suma a otra. Ambas operaciones deben realizarse o no debe realizarse ninguna.

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

Gestionar errores con try/except

Envuelva una transacción en try/except. Si se produce un error, revierta los cambios para que los cambios parciales no dañen sus datos.

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 conexión como administrador de contexto

Usar with conn: confirma automáticamente la transacción si todo va bien y la revierte si se produce una excepción dentro del bloque.

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

Reversión automática ante excepciones

Si el bloque with conn: genera una excepción, la transacción se revierte automáticamente. Tenga en cuenta que la conexión permanece abierta.

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 la conexión

La utilidad contextlib.closing garantiza que se llame a close() cuando termina el bloque, lo que libera la conexión.

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

Combinar ambos patrones

Anide with conn: dentro de closing(...) para gestionar la transacción y asegurarse de que la conexión se cierre.

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 de la conexión controla cuándo comienzan las transacciones. El valor predeterminado permite que SQLite lo gestione; establecerlo en None activa el modo de confirmación 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 qué son importantes las transacciones

Sin transacciones, un fallo en mitad de una actualización podría dejar los datos incompletos. Las transacciones hacen que un conjunto de cambios sea atómico: indivisible. Esto protege la integridad.

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

Comprobación rápida

Compruebe sus conocimientos sobre transacciones.

Resumen

Ha aprendido a gestionar transacciones de forma segura.

  • commit() guarda los cambios; rollback() los deshace
  • Envuelva las escrituras de riesgo en try/except con una reversión
  • with conn: confirma o revierte automáticamente
  • contextlib.closing garantiza que la conexión se cierre

Preguntas frecuentes

¿La lección «Transacciones y gestores de contexto» es gratis?

Sí — el texto completo de «Transacciones y gestores de contexto» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Transacciones y gestores de contexto»?

Confirme y revierta operaciones de forma segura Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Transacciones y gestores de contexto»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conexión y creación de tablas
  2. Insertar, seleccionar, actualizar y eliminar
  3. Consultas parametrizadas
  4. Transacciones y gestores de contexto
← Volver a Python Academy