Python habla con bases de datos: conectar, consultar, guardar

1import sqlite3
2
3# Opción A: base de datos en un archivo (persiste en disco)
4# conn = sqlite3.connect('mi_base.db')
5
6# Opción B: base de datos en memoria (desaparece al cerrar el programa)
7# Perfecta para aprender y para tests: siempre empieza limpia
8conn = sqlite3.connect(':memory:')
9
10# Verificar que la conexión funciona
11cursor = conn.execute('SELECT sqlite_version()')
12print('Conectado a SQLite version:', cursor.fetchone()[0])
13
14conn.close()

Tu "hola mundo" con sqlite3: conectar y preguntar la versión

1import sqlite3
2
3conn = sqlite3.connect(':memory:')
4
5# Crear una tabla (mismo SQL que en PostgreSQL o DuckDB)
6conn.execute('''
7    CREATE TABLE clientes (
8        id INTEGER PRIMARY KEY,
9        nombre TEXT NOT NULL,
10        ciudad TEXT,
11        total_gastado REAL
12    )
13''')
14
15# Insertar datos de ejemplo (varias filas de una vez con executemany)
16clientes = [
17    (1, 'Ana',    'Madrid',    5400.0),
18    (2, 'Carlos', 'Barcelona', 1200.0),
19    (3, 'Lucía',  'Madrid',    8900.0),
20    (4, 'Pedro',  'Sevilla',    320.0),
21    (5, 'María',  'Barcelona', 6100.0),
22]
23conn.executemany(
24    'INSERT INTO clientes (id, nombre, ciudad, total_gastado) VALUES (?, ?, ?, ?)',
25    clientes
26)
27
28# CONFIRMAR los cambios: sin commit, no se guardan
29conn.commit()
30
31# Comprobar cuántas filas hay
32n = conn.execute('SELECT COUNT(*) FROM clientes').fetchone()[0]
33print(f'Insertados {n} clientes')
34
35conn.close()

CREATE TABLE + INSERT con sqlite3: el SQL es el mismo que ya dominas

1import sqlite3
2import pandas as pd
3
4conn = sqlite3.connect(':memory:')
5conn.execute('''
6    CREATE TABLE clientes (
7        id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT, total_gastado REAL
8    )
9''')
10conn.executemany(
11    'INSERT INTO clientes VALUES (?, ?, ?, ?)',
12    [
13        (1, 'Ana',    'Madrid',    5400.0),
14        (2, 'Carlos', 'Barcelona', 1200.0),
15        (3, 'Lucía',  'Madrid',    8900.0),
16        (4, 'Pedro',  'Sevilla',    320.0),
17        (5, 'María',  'Barcelona', 6100.0),
18    ]
19)
20conn.commit()
21
22# Leer una tabla completa a un DataFrame
23clientes = pd.read_sql('SELECT * FROM clientes', conn)
24print(f'Clientes: {len(clientes)} filas')
25
26# Leer con filtros y agregación (la base de datos hace el trabajo pesado)
27resumen = pd.read_sql('''
28    SELECT ciudad,
29           COUNT(*)          AS num_clientes,
30           SUM(total_gastado) AS gasto_total
31    FROM clientes
32    GROUP BY ciudad
33    HAVING SUM(total_gastado) > 1000
34    ORDER BY gasto_total DESC
35''', conn)
36
37print(resumen)
38
39conn.close()

read_sql combina SQL + Pandas: filtra y agrega en la DB, transforma en Python

1import sqlite3
2import pandas as pd
3
4conn = sqlite3.connect(':memory:')
5
6# DataFrame con datos ya procesados
7resumen = pd.DataFrame({
8    'mes': ['2024-01', '2024-02', '2024-03'],
9    'total_ventas': [125000, 148000, 132000],
10    'num_pedidos': [450, 520, 480],
11    'ticket_medio': [277.8, 284.6, 275.0]
12})
13
14# Escribir el DataFrame en una tabla de la base de datos
15resumen.to_sql(
16    'resumen_mensual',      # nombre de la tabla
17    conn,                   # la conexión sqlite3
18    if_exists='replace',    # 'fail', 'replace', 'append'
19    index=False             # no guardar el índice de Pandas como columna
20)
21
22print('Datos escritos correctamente')
23
24# Verificar leyendo de vuelta (ORDER BY para salida determinista)
25check = pd.read_sql('SELECT * FROM resumen_mensual ORDER BY mes', conn)
26print(check)
27
28conn.close()

to_sql escribe un DataFrame directamente en una tabla de la base de datos

1import sqlite3
2import pandas as pd
3
4conn = sqlite3.connect(':memory:')
5conn.execute('CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, total_gastado REAL)')
6conn.executemany('INSERT INTO clientes VALUES (?, ?, ?, ?)', [
7    (1, 'Ana', 'Madrid', 5400.0),
8    (2, 'Carlos', 'Barcelona', 1200.0),
9    (3, 'Lucía', 'Madrid', 8900.0),
10])
11conn.commit()
12
13# CORRECTO: placeholders ? y los valores en una tupla aparte
14ciudad = 'Madrid'
15minimo = 2000.0
16query = '''
17    SELECT nombre, total_gastado
18    FROM clientes
19    WHERE ciudad = ? AND total_gastado >= ?
20    ORDER BY total_gastado DESC
21'''
22df = pd.read_sql(query, conn, params=(ciudad, minimo))
23print(df)
24
25# INCORRECTO (NO lo hagas): f"... WHERE ciudad = '{ciudad}'"
26# Si 'ciudad' viniera de un formulario, alguien podría inyectar SQL malicioso.
27
28conn.close()

sqlite3 usa ? como placeholder; los valores van en params, nunca en el string

1import sqlite3
2import pandas as pd
3
4def pipeline_resumen_ventas(conn):
5    """Mini-ETL: calcula un resumen de ventas por producto desde datos crudos."""
6
7    # EXTRACT: leer datos crudos (aquí filtramos lo que nos interesa)
8    ventas = pd.read_sql('''
9        SELECT producto_id, cantidad, precio_unitario
10        FROM ventas_raw
11    ''', conn)
12    print(f'Extraídas {len(ventas)} ventas')
13
14    # TRANSFORM: limpiar y agregar en Pandas
15    ventas['importe'] = ventas['cantidad'] * ventas['precio_unitario']
16    resumen = ventas.groupby('producto_id').agg(
17        total_ventas=('importe', 'sum'),
18        num_transacciones=('importe', 'count'),
19        ticket_medio=('importe', 'mean')
20    ).reset_index()
21
22    # LOAD: escribir el resultado en una tabla nueva
23    resumen.to_sql('resumen_ventas', conn, if_exists='replace', index=False)
24    print(f'Cargadas {len(resumen)} filas en resumen_ventas')
25    return resumen
26
27# --- Preparar datos de ejemplo y ejecutar ---
28conn = sqlite3.connect(':memory:')
29conn.execute('CREATE TABLE ventas_raw (producto_id INTEGER, cantidad INTEGER, precio_unitario REAL)')
30conn.executemany('INSERT INTO ventas_raw VALUES (?, ?, ?)', [
31    (1, 2, 10.0), (1, 3, 10.0), (2, 1, 50.0), (2, 4, 50.0), (3, 5, 8.0),
32])
33conn.commit()
34
35resultado = pipeline_resumen_ventas(conn)
36print(resultado.sort_values('producto_id').to_string(index=False))
37conn.close()

Mini-ETL completo con sqlite3: Extract → Transform → Load, ejecutable de principio a fin

1import os
2import pandas as pd
3from sqlalchemy import create_engine, text
4
5# 1) Crear el engine: la URL sustituye a la ruta del archivo de sqlite
6#    formato: dialecto+driver://usuario:contraseña@host:puerto/base
7db_url = os.environ.get(
8    'DATABASE_URL',
9    'postgresql+psycopg2://postgres:postgres@localhost:5432/tienda'
10)
11engine = create_engine(db_url)
12
13# 2) Leer: EXACTAMENTE la misma llamada que con sqlite3
14clientes = pd.read_sql('SELECT * FROM clientes', engine)
15
16# 3) Escribir: igual que con sqlite3
17clientes.to_sql('clientes_backup', engine, if_exists='replace', index=False)
18
19# 4) Parametrizadas: PostgreSQL/SQLAlchemy usa :nombre + diccionario
20#    (sqlite3 usaba ? + tupla; el concepto es el mismo)
21query = text('SELECT * FROM clientes WHERE ciudad = :ciudad AND total_gastado >= :minimo')
22df = pd.read_sql(query, engine, params={'ciudad': 'Madrid', 'minimo': 2000})
23print(df)

El mismo patrón contra PostgreSQL: cambia la conexión (engine) y el estilo de placeholder, nada más