Data Analysis · Lección 17 de 19

Integración SQL + Python

Ya dominás SQL para consultar bases de datos y Python/pandas para analizar datos. Ahora aprendé a conectar ambos mundos: ejecutar queries SQL desde Python, cargar resultados directamente en DataFrames y escribir pipelines automatizados que combinen lo mejor de cada tecnología.

90–120 min Prerrequisitos: SQL (sección completa) + pandas

Concepto teórico

¿Por qué integrar SQL + Python?

SQL es excelente para extraer y filtrar datos de millones de filas en el servidor. Python es excelente para análisis estadístico, visualización y ML en tu máquina local. La integración te da lo mejor de ambos:

Tarea	Mejor herramienta	¿Por qué?
Filtrar millones de filas	SQL	El motor SQL está optimizado para esto
JOINs complejos	SQL	Indexado del servidor es mucho más rápido
Análisis estadístico	Python	scipy, statsmodels, pandas
Visualización	Python	matplotlib, seaborn
Machine Learning	Python	scikit-learn, TensorFlow
Automatizar reportes	Python	Scripts programables
Data cleaning complejo	Python	pandas es más flexible que SQL procesales

Analogía del restaurante: SQL es la cocina — tiene los hornos industriales, las heladeras con toda la materia prima, puede servir 1000 platos. Python es el sommelier — toma el plato ya preparado (los datos filtrados) y le agrega el toque final: maridaje con vino (visualización), evaluación de calidad (estadísticas), y la recomendación al comensal (el insight). Cada uno en lo suyo.

Las librerías de conexión

Librería	Base de datos	Tipo
`sqlite3`	SQLite	Incluida en Python (no necesita instalar)
`psycopg2`	PostgreSQL	Más usada en producción
`pymysql`	MySQL/MariaDB	Empresas legacy
`pyodbc`	SQL Server	Ecosistema Microsoft
`sqlalchemy`	Cualquiera (ORM)	Capa de abstracción universal

El flujo estándar:
1. conn = sqlite3.connect("mi_base.db") → abrir conexión
2. df = pd.read_sql("SELECT ...", conn) → query → DataFrame
3. Analizar, visualizar, modelar con pandas/seaborn/sklearn
4. (Opcional) df.to_sql("tabla", conn) → guardar resultados de vuelta
5. conn.close() → cerrar conexión

pd.read_sql(): el puente mágico

Esta función es la llave maestra: ejecuta una query SQL y devuelve el resultado directamente como DataFrame de pandas. Todo lo que sabés de SQL funciona dentro del string de la query.

Regla de oro: filtrá y agregá en SQL lo que puedas, y traé a Python solo los datos que vas a analizar. Si tu base tiene 50 millones de filas, no hagas pd.read_sql("SELECT * FROM tabla", conn). Hacé SELECT con WHERE, GROUP BY y LIMIT para traer lo necesario.

En el trabajo real: el día a día de un Data Analyst es: (1) abrir Jupyter Notebook, (2) conectarse al data warehouse con sqlalchemy + psycopg2, (3) ejecutar queries, (4) explorar en pandas, (5) generar visualizaciones y presentar. Todo en un mismo flujo, de forma reproducible.

Ejemplos explicados paso a paso

Ejemplo 1: Crear una base SQLite y cargar datos desde pandas

SQLite está incluida en Python — no necesitás instalar nada. Es perfecta para aprender y para proyectos locales.

ejemplo_01_crear_db.pyPython

import sqlite3
import pandas as pd
import numpy as np

np.random.seed(42)

# Crear datos
clientes = pd.DataFrame({
    "cliente_id": range(1, 51),
    "nombre": [f"Cliente_{i}" for i in range(1, 51)],
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba","Mendoza"], 50),
    "segmento": np.random.choice(["Premium","Estándar","Básico"], 50, p=[0.15,0.55,0.30])
})

transacciones = pd.DataFrame({
    "txn_id": range(1, 201),
    "cliente_id": np.random.randint(1, 51, 200),
    "monto": np.random.randint(1000, 50000, 200),
    "fecha": pd.date_range("2024-01-01", periods=200, freq="D").strftime("%Y-%m-%d"),
    "producto": np.random.choice(["Cuenta","Tarjeta","Préstamo"], 200)
})

# Crear base SQLite y cargar tablas
conn = sqlite3.connect(":memory:")  # Base en memoria
clientes.to_sql("clientes", conn, index=False, if_exists="replace")
transacciones.to_sql("transacciones", conn, index=False, if_exists="replace")

# Verificar
tablas = pd.read_sql("SELECT name FROM sqlite_master WHERE type='table'", conn)
print("=== Tablas creadas ===")
print(tablas)

# Contar filas
for tabla in ["clientes", "transacciones"]:
    n = pd.read_sql(f"SELECT COUNT(*) as filas FROM {tabla}", conn)
    print(f"  {tabla}: {n['filas'][0]} filas")

conn.close()

Hacé clic en ▶ Ejecutar

Ejemplo 2: pd.read_sql() — ejecutar queries y obtener DataFrames

El flujo principal: escribís SQL, obtenés un DataFrame. Lo mejor de los dos mundos.

ejemplo_02_read_sql.pyPython

import sqlite3
import pandas as pd
import numpy as np

np.random.seed(42)
conn = sqlite3.connect(":memory:")
clientes = pd.DataFrame({
    "cliente_id": range(1, 51),
    "nombre": [f"Cliente_{i}" for i in range(1, 51)],
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba","Mendoza"], 50),
    "segmento": np.random.choice(["Premium","Estándar","Básico"], 50, p=[0.15,0.55,0.30])
})
transacciones = pd.DataFrame({
    "txn_id": range(1, 201),
    "cliente_id": np.random.randint(1, 51, 200),
    "monto": np.random.randint(1000, 50000, 200),
    "fecha": pd.date_range("2024-01-01", periods=200, freq="D").strftime("%Y-%m-%d"),
    "producto": np.random.choice(["Cuenta","Tarjeta","Préstamo"], 200)
})
clientes.to_sql("clientes", conn, index=False)
transacciones.to_sql("transacciones", conn, index=False)

# 1. Query simple → DataFrame
print("=== Query 1: Top 5 transacciones ===")
df1 = pd.read_sql("SELECT * FROM transacciones ORDER BY monto DESC LIMIT 5", conn)
print(df1)

# 2. Query con WHERE
print("\n=== Query 2: Clientes Premium de CABA ===")
df2 = pd.read_sql("""
    SELECT nombre, ciudad, segmento 
    FROM clientes 
    WHERE segmento = 'Premium' AND ciudad = 'CABA'
""", conn)
print(df2)

# 3. Query con JOIN + GROUP BY
print("\n=== Query 3: Ventas por ciudad (SQL hace el JOIN + GROUP BY) ===")
df3 = pd.read_sql("""
    SELECT c.ciudad, 
           COUNT(*) as operaciones,
           SUM(t.monto) as total,
           ROUND(AVG(t.monto), 0) as ticket_promedio
    FROM transacciones t
    JOIN clientes c ON t.cliente_id = c.cliente_id
    GROUP BY c.ciudad
    ORDER BY total DESC
""", conn)
print(df3)

conn.close()

Hacé clic en ▶ Ejecutar

Ejemplo 3: SQL para filtrar + pandas para analizar

El patrón profesional: dejá que SQL haga el trabajo pesado (filtrar, JOINs), y usá pandas para lo que hace mejor (estadísticas, EDA).

ejemplo_03_sql_pandas.pyPython

import sqlite3
import pandas as pd
import numpy as np

np.random.seed(42)
conn = sqlite3.connect(":memory:")

clientes = pd.DataFrame({
    "cliente_id": range(1, 101),
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba"], 100),
    "segmento": np.random.choice(["Premium","Estándar","Básico"], 100, p=[0.2,0.5,0.3]),
    "antiguedad": np.random.randint(0, 20, 100)
})
txn = pd.DataFrame({
    "cliente_id": np.random.randint(1, 101, 500),
    "monto": np.random.randint(1000, 80000, 500),
    "producto": np.random.choice(["Cuenta","Tarjeta","Préstamo"], 500)
})
clientes.to_sql("clientes", conn, index=False)
txn.to_sql("transacciones", conn, index=False)

# PASO 1: SQL filtra y une (trabajo pesado en el servidor)
query = """
    SELECT c.segmento, c.ciudad, c.antiguedad,
           t.monto, t.producto
    FROM transacciones t
    JOIN clientes c ON t.cliente_id = c.cliente_id
    WHERE c.antiguedad >= 3
"""
df = pd.read_sql(query, conn)
print(f"SQL retornó {len(df)} filas (ya filtradas y unidas)")

# PASO 2: pandas analiza (estadísticas avanzadas)
print(f"\n=== EDA rápido con pandas ===")
print(f"Segmentos: {df['segmento'].value_counts().to_dict()}")
print(f"\nEstadísticas por segmento:")
resumen = df.groupby("segmento")["monto"].agg(["mean","median","std","count"]).round(0)
print(resumen)

# PASO 3: Insight
top_seg = resumen["mean"].idxmax()
print(f"\n💡 Insight: '{top_seg}' tiene el ticket promedio más alto")
print(f"   Ticket: ${resumen.loc[top_seg, 'mean']:,.0f}")

conn.close()

Hacé clic en ▶ Ejecutar

Tip pro — queries parametrizadas: nunca concatená variables en un string SQL (f"WHERE id = {id}") — es vulnerable a SQL injection. Usá parámetros: pd.read_sql("SELECT * FROM t WHERE id = ?", conn, params=[id]).

Ejemplo 4: Guardar resultados de vuelta en SQL

Después de procesar datos en pandas, podés guardar los resultados en una tabla SQL para que otros los consuman.

ejemplo_04_to_sql.pyPython

import sqlite3
import pandas as pd
import numpy as np

np.random.seed(42)
conn = sqlite3.connect(":memory:")

# Datos originales
txn = pd.DataFrame({
    "cliente_id": np.random.randint(1, 51, 200),
    "monto": np.random.randint(1000, 50000, 200),
    "producto": np.random.choice(["Cuenta","Tarjeta","Préstamo"], 200)
})
txn.to_sql("transacciones", conn, index=False)

# Calcular resumen en pandas
resumen = txn.groupby("cliente_id").agg(
    total_ventas=("monto", "sum"),
    cantidad_txn=("monto", "count"),
    ticket_promedio=("monto", "mean"),
    producto_favorito=("producto", lambda x: x.mode().iloc[0])
).round(0).reset_index()

# Guardar resumen como nueva tabla SQL
resumen.to_sql("resumen_clientes", conn, index=False, if_exists="replace")

# Verificar: leer la nueva tabla
print("=== Tabla 'resumen_clientes' guardada en SQL ===")
check = pd.read_sql("SELECT * FROM resumen_clientes ORDER BY total_ventas DESC LIMIT 10", conn)
print(check)

# Usar la nueva tabla en un query
top3 = pd.read_sql("""
    SELECT cliente_id, total_ventas, producto_favorito
    FROM resumen_clientes
    WHERE cantidad_txn >= 5
    ORDER BY total_ventas DESC
    LIMIT 3
""", conn)
print(f"\n=== Top 3 clientes con ≥5 operaciones ===")
print(top3)

conn.close()

Hacé clic en ▶ Ejecutar

Ejemplo 5: Pipeline completo — SQL → pandas → visualización

Un pipeline de análisis real: extraer de SQL, procesar en pandas, visualizar con matplotlib.

ejemplo_05_pipeline.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import sqlite3
import pandas as pd
import numpy as np

np.random.seed(42)
conn = sqlite3.connect(":memory:")

# Simular base de datos
fechas = pd.date_range("2024-01-01", periods=365, freq="D")
txn = pd.DataFrame({
    "fecha": fechas.strftime("%Y-%m-%d"),
    "sucursal": np.random.choice(["CABA","Rosario","Córdoba"], 365),
    "monto": np.random.normal(15000, 5000, 365).astype(int)
})
txn.to_sql("ventas", conn, index=False)

# PASO 1: SQL extrae datos agregados por mes y sucursal
df = pd.read_sql("""
    SELECT substr(fecha, 1, 7) as mes,
           sucursal,
           SUM(monto) as total,
           COUNT(*) as operaciones
    FROM ventas
    GROUP BY mes, sucursal
    ORDER BY mes
""", conn)
print(f"SQL retornó {len(df)} filas (mensual × sucursal)")

# PASO 2: pandas pivotea
pivot = df.pivot_table(values="total", index="mes", columns="sucursal", aggfunc="sum", fill_value=0)

# PASO 3: matplotlib visualiza
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

pivot.plot(kind="line", marker="o", ax=axes[0])
axes[0].set_title("Tendencia Mensual por Sucursal", fontweight="bold")
axes[0].tick_params(axis="x", rotation=45)
axes[0].set_ylabel("Ventas ($)")
axes[0].grid(True, alpha=0.3)

totales = df.groupby("sucursal")["total"].sum()
axes[1].bar(totales.index, totales.values, color=["#2196F3","#4CAF50","#FF9800"])
axes[1].set_title("Total Anual por Sucursal", fontweight="bold")
for i, v in enumerate(totales.values):
    axes[1].text(i, v+10000, f"${v:,.0f}", ha="center", fontsize=9, fontweight="bold")

plt.tight_layout()
plt.show()

print("\nPipeline: SQL (extracción) → pandas (transformación) → matplotlib (visualización)")
conn.close()

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Código
Conectar (SQLite)	`conn = sqlite3.connect("base.db")`
Conectar en memoria	`conn = sqlite3.connect(":memory:")`
Query → DataFrame	`pd.read_sql("SELECT ...", conn)`
Query parametrizada	`pd.read_sql("... WHERE id=?", conn, params=[id])`
DataFrame → SQL	`df.to_sql("tabla", conn, if_exists="replace")`
Listar tablas	`pd.read_sql("SELECT name FROM sqlite_master WHERE type='table'", conn)`
Cerrar conexión	`conn.close()`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear tabla y consultar

Creá una tabla SQL con to_sql y leéla con read_sql. Debe incluir CABA.

ejercicio_01.pyDebe incluir "CABA"

import sqlite3
import pandas as pd

df = pd.DataFrame({
    "Nombre": ["Ana", "Luis", "Pedro"],
    "Ciudad": ["CABA", "Rosario", "Córdoba"]
})

conn = sqlite3.connect(":memory:")
# Guardar en SQL y leer de vuelta

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: SELECT con WHERE

Consultá los clientes de Rosario. Debe incluir Rosario.

ejercicio_02.pyDebe incluir "Rosario"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
df = pd.DataFrame({
    "nombre": [f"Cliente_{i}" for i in range(20)],
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba"], 20)
})
df.to_sql("clientes", conn, index=False)

# SELECT WHERE ciudad = 'Rosario'

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: COUNT y SUM en SQL

Contá cuántas transacciones hay y sumá los montos con SQL. Debe incluir total.

ejercicio_03.pyDebe incluir "total"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "monto": np.random.randint(1000, 50000, 100)
}).to_sql("ventas", conn, index=False)

# COUNT y SUM con SQL

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: JOIN en SQL → DataFrame

Hacé un JOIN entre clientes y transacciones. Imprimí el DataFrame resultante. Debe incluir ciudad.

ejercicio_04.pyDebe incluir "ciudad"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
clientes = pd.DataFrame({"id": [1,2,3], "nombre": ["Ana","Luis","Marta"], "ciudad": ["CABA","Rosario","Córdoba"]})
txn = pd.DataFrame({"txn_id": range(1,7), "cliente_id": [1,2,1,3,2,1], "monto": [100,200,150,300,250,180]})
clientes.to_sql("clientes", conn, index=False)
txn.to_sql("transacciones", conn, index=False)

# JOIN

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: GROUP BY en SQL + análisis en pandas

Hacé GROUP BY por ciudad en SQL, luego calculá el % de participación en pandas. Debe incluir %.

ejercicio_05.pyDebe incluir "%"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba"], 100),
    "monto": np.random.randint(5000, 30000, 100)
}).to_sql("ventas", conn, index=False)

# SQL: GROUP BY ciudad → pandas: agregar %

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Guardar resultados con to_sql

Calculá un resumen en pandas y guardálo como nueva tabla SQL. Verificá leyéndolo. Debe incluir resumen.

ejercicio_06.pyDebe incluir "resumen"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "producto": np.random.choice(["A","B","C"], 80),
    "monto": np.random.randint(100, 1000, 80)
}).to_sql("ventas", conn, index=False)

# 1. Leer, agrupar en pandas
# 2. to_sql como "resumen_productos"
# 3. Verificar con read_sql

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Query parametrizada

Usá una query con parámetro ? para filtrar por una ciudad específica. Debe incluir Córdoba.

ejercicio_07.pyDebe incluir "Córdoba"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "nombre": [f"C{i}" for i in range(20)],
    "ciudad": np.random.choice(["CABA","Rosario","Córdoba"], 20)
}).to_sql("clientes", conn, index=False)

ciudad_buscada = "Córdoba"

# Query con parámetro ? (no f-string!)

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: SQL → pandas → estadísticas

Extraé datos con SQL, luego calculá media, mediana y percentil 90 en pandas. Debe incluir P90.

ejercicio_08.pyDebe incluir "P90"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "monto": np.random.normal(15000, 5000, 200).astype(int)
}).to_sql("ventas", conn, index=False)

# SQL: extraer → pandas: estadísticas avanzadas

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Pipeline SQL → pandas → gráfico

Extraé ventas mensuales con SQL, luego graficá la tendencia. Imprimí Pipeline OK.

ejercicio_09.pyDebe imprimir "Pipeline OK"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")
pd.DataFrame({
    "fecha": pd.date_range("2024-01-01", periods=180, freq="D").strftime("%Y-%m-%d"),
    "monto": np.random.normal(15000, 5000, 180).astype(int)
}).to_sql("ventas", conn, index=False)

# SQL: agrupar por mes → pandas: gráfico de línea

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline completo con 2 tablas

Creá 2 tablas (clientes + ventas), hacé JOIN en SQL, calculá métricas por segmento en pandas, y guardá el resultado como nueva tabla. Debe incluir Pipeline completo.

ejercicio_10_desafio.pyDebe imprimir "Pipeline completo"

import sqlite3
import pandas as pd
import numpy as np
np.random.seed(42)

conn = sqlite3.connect(":memory:")

# Crear tablas
pd.DataFrame({
    "id": range(1, 31), 
    "segmento": np.random.choice(["Premium","Estándar","Básico"], 30)
}).to_sql("clientes", conn, index=False)

pd.DataFrame({
    "cliente_id": np.random.randint(1, 31, 100),
    "monto": np.random.randint(1000, 50000, 100)
}).to_sql("ventas", conn, index=False)

# 1. JOIN en SQL
# 2. Métricas por segmento en pandas
# 3. to_sql como "resumen_segmentos"
# 4. Verificar + imprimir "Pipeline completo"

Hacé clic en ▶ Ejecutar

Resumen y conexión

pd.read_sql(query, conn) es el puente entre SQL y pandas — ejecuta queries y devuelve DataFrames.
df.to_sql("tabla", conn) guarda DataFrames como tablas SQL.
Regla de oro: filtrá en SQL, analizá en pandas. No traigas millones de filas si solo necesitás un resumen.
Usá queries parametrizadas (?) para evitar SQL injection.
sqlite3 viene incluida en Python — perfecta para aprender y prototipar.
En producción se usa sqlalchemy como capa de abstracción universal.

En la siguiente lección (18 · Portfolio y proyecto final) vas a aplicar todo lo aprendido en un proyecto completo de Data Analysis, construyendo tu portfolio profesional.

Hecho con ❤️ por Rodri Gonzalez