Conectarse a una base de datos con SQLAlchemy
Cree un motor de SQLAlchemy para SQLite y PostgreSQL y páselo a pd.read_sql para cargar una tabla en un DataFrame.
Conectarse a una base de datos con SQLAlchemy es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 1 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 Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Por qué conectar Pandas con bases de datos?
La mayoría de los datos de producción se encuentran en bases de datos relacionales —PostgreSQL, MySQL, SQLite o SQL Server—, no en archivos CSV. Conectar Pandas directamente a una base de datos permite consultar datos en un DataFrame sin exportarlos primero a CSV, volver a guardar DataFrames limpios en tablas y combinar la potencia analítica de Python con las capacidades de indexación y combinación de la base de datos. El puente entre Pandas y las bases de datos es SQLAlchemy, la biblioteca estándar de abstracción de bases de datos de Python.
Instalar SQLAlchemy
SQLAlchemy es un conjunto de herramientas SQL y un ORM para Python. Para la integración con Pandas solo necesita la capa Core, no el ORM. Instálelo con pip install sqlalchemy. También necesita el controlador específico de la base de datos: psycopg2 para PostgreSQL, pymysql para MySQL o sqlite3 (incluido en Python) para SQLite. SQLAlchemy actúa como una capa de abstracción: el mismo código de Pandas funciona con cualquier base de datos compatible cambiando únicamente la cadena de conexión.
# Install dependencies
# pip install sqlalchemy psycopg2-binary # for PostgreSQL
# pip install sqlalchemy pymysql # for MySQL
# sqlite3 is built into Python
import sqlalchemy as sa
import pandas as pd
print('SQLAlchemy version:', sa.__version__)Crear un motor de conexión
El primer paso consiste en crear un motor de SQLAlchemy mediante una URL de conexión que codifica el tipo de base de datos, las credenciales, el host, el puerto y el nombre de la base de datos. El motor es una fábrica de conexiones de base de datos: no abre una conexión hasta que realmente se necesita. Pase el motor a las funciones pd.read_sql() y df.to_sql() de Pandas. Nunca incluya las credenciales directamente en el código; léalas de variables de entorno o de un gestor de secretos.
import sqlalchemy as sa
import os
# SQLite (file-based, no server needed)
sqlite_engine = sa.create_engine('sqlite:///mydata.db')
# PostgreSQL
# pg_url = 'postgresql://user:pass@localhost:5432/mydb'
# pg_engine = sa.create_engine(pg_url)
# From environment variable (safer)
# pg_engine = sa.create_engine(os.environ['DATABASE_URL'])
print(sqlite_engine)
print(type(sqlite_engine))Leer una tabla con pd.read_sql_table()
pd.read_sql_table('table_name', con=engine) lee una tabla de base de datos completa en un DataFrame. Infere automáticamente los tipos de datos de las columnas a partir del esquema de la base de datos: los enteros se mantienen como enteros, las marcas de tiempo como datetime, etc. Esto es más preciso que la inferencia de CSV. También puede limitar las columnas con el argumento columns y especificar esquemas de base de datos que no sean el predeterminado con schema. Tenga cuidado con las tablas muy grandes: todo el contenido se carga en la RAM.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Read a full table
df = pd.read_sql_table('orders', con=engine)
print(df.shape)
print(df.dtypes)
print(df.head())Ejecutar consultas con pd.read_sql_query()
pd.read_sql_query('SELECT ...', con=engine) ejecuta cualquier instrucción SQL SELECT y devuelve los resultados como un DataFrame. Es el enfoque más flexible: puede filtrar, combinar y agregar datos en SQL antes de cargarlos en Pandas, de modo que solo cargue las filas y columnas que necesita. Escriba la consulta como una cadena de Python normal. Nunca concatene entradas del usuario en las consultas; utilice consultas parametrizadas para evitar la inyección SQL.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
query = '''
SELECT customer_id, SUM(amount) AS total_spent,
COUNT(*) AS num_orders
FROM orders
WHERE status = 'completed'
GROUP BY customer_id
ORDER BY total_spent DESC
LIMIT 100
'''
top_customers = pd.read_sql_query(query, con=engine)
print(top_customers.head())Consultas parametrizadas para mayor seguridad
Nunca cree consultas SQL concatenando cadenas con valores proporcionados por el usuario, ya que esto abre vulnerabilidades de inyección SQL. En su lugar, utilice consultas parametrizadas: pase los parámetros como un diccionario con marcadores de posición con nombre. SQLAlchemy se encarga de escapar los valores. La sintaxis de los marcadores de posición es :name en las consultas de texto de SQLAlchemy o %(name)s en las consultas con el estilo de psycopg2. Utilice siempre la parametrización, incluso en scripts internos, para adquirir buenos hábitos.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Safe: parameterised query
params = {'status': 'completed', 'min_amount': 500.0}
query = sa.text(
'SELECT * FROM orders WHERE status = :status AND amount > :min_amount'
)
with engine.connect() as conn:
df = pd.read_sql_query(query, con=conn, params=params)
print(f'Loaded {len(df)} rows')Gestionar resultados grandes en bloques
Para resultados de consultas grandes, utilice chunksize en pd.read_sql_query() para recibir un iterador de DataFrames en lugar de cargarlo todo de una vez. Esto refleja el comportamiento de pd.read_csv(chunksize=...), pero obtiene las filas de la base de datos por lotes. Combine esta técnica con un patrón de acumulador progresivo para agregar los resultados de consultas con millones de filas sin agotar la RAM.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('postgresql://user:pass@host/db')
total = 0.0
count = 0
for chunk in pd.read_sql_query(
'SELECT amount FROM orders',
con=engine,
chunksize=50000
):
total += chunk['amount'].sum()
count += len(chunk)
print(f'Mean amount: {total/count:.2f}')Gestores de contexto para conexiones
Abra siempre las conexiones de base de datos dentro de un gestor de contexto (with engine.connect() as conn:) para garantizar que la conexión se cierre correctamente incluso si se produce una excepción. Olvidar cerrar las conexiones provoca el agotamiento del grupo de conexiones en producción, lo que hace que las consultas nuevas se queden esperando un espacio libre. El grupo de conexiones de SQLAlchemy administra un número fijo de conexiones y las reutiliza automáticamente cuando se utilizan gestores de contexto.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
# Using context manager — connection always closed properly
with engine.connect() as conn:
df = pd.read_sql_query(
'SELECT * FROM products WHERE category = "Electronics"',
con=conn
)
print(f'Products loaded: {len(df)}')
# Connection is automatically returned to the pool hereInspeccionar el esquema de la base de datos
Antes de escribir consultas, necesita saber qué tablas y columnas existen. El Inspector de SQLAlchemy permite reflejar el esquema de la base de datos sin escribir SQL sin procesar. inspector.get_table_names() muestra todas las tablas; inspector.get_columns('table') devuelve los nombres y tipos de las columnas. Esto resulta útil al trabajar con bases de datos desconocidas y es más limpio que ejecutar manualmente PRAGMA table_info() o \d tablename.
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///sales.db')
inspector = sa.inspect(engine)
# List all tables
tables = inspector.get_table_names()
print('Tables:', tables)
# Get columns for the 'orders' table
for col in inspector.get_columns('orders'):
print(f' {col["name"]}: {col["type"]}')Cerrar motores y aplicar buenas prácticas
En scripts de larga duración o aplicaciones web, llame a engine.dispose() cuando termine para cerrar todas las conexiones del grupo. En scripts cortos, el recolector de basura de Python se encarga de la limpieza. Buenas prácticas para las conexiones de base de datos en las canalizaciones de datos: cree el motor una sola vez al principio del script y reutilícelo, mantenga los valores predeterminados del grupo de conexiones (pool_size=5) y active pool_pre_ping=True para volver a conectarse automáticamente si el servidor de base de datos se reinicia entre consultas.
import sqlalchemy as sa
# Production-grade engine creation
engine = sa.create_engine(
'postgresql://user:pass@host:5432/mydb',
pool_size=5, # max 5 persistent connections
max_overflow=10, # allow 10 temporary extra connections
pool_pre_ping=True, # verify connection before use
connect_args={'connect_timeout': 10}
)
# ... run all your queries ...
# At the end of the application/script
engine.dispose()
print('Engine disposed')Comparar la velocidad de read_sql y read_csv
Para datos que ya están en una base de datos con índices adecuados, pd.read_sql_query con una consulta filtrada suele ser más rápido que exportarlos a CSV y leerlos. El servidor de base de datos aplica los filtros antes de enviar los datos, lo que reduce la transferencia por red y el coste de análisis. En tablas muy anchas, la base de datos también puede seleccionar únicamente las columnas necesarias. Sin embargo, leer desde una base de datos remota a través de una red lenta puede ser más lento que leer un archivo Parquet local; perfile siempre ambas opciones para su configuración específica.
import pandas as pd
import sqlalchemy as sa
import time
engine = sa.create_engine('sqlite:///data.db')
# Database read with server-side filter
start = time.time()
df_sql = pd.read_sql_query(
'SELECT * FROM transactions WHERE amount > 100 AND year = 2024',
con=engine
)
print(f'SQL read: {time.time()-start:.3f}s, {len(df_sql):,} rows')Comprobación rápida
Ponga a prueba su comprensión de los conceptos de análisis de datos de esta lección.
Resumen de la lección
En esta lección ha aprendido que sa.create_engine() crea una fábrica de conexiones reutilizable a partir de una cadena de URL; pd.read_sql_query() ejecuta SQL arbitrario y devuelve un DataFrame; y las consultas parametrizadas con sa.text() y params evitan las vulnerabilidades de inyección SQL. A continuación, veremos cómo ejecutar consultas SQL más complejas desde Pandas y combinar SQL con lógica de Python.
Preguntas frecuentes
¿La lección «Conectarse a una base de datos con SQLAlchemy» es gratis?
Sí — el texto completo de «Conectarse a una base de datos con SQLAlchemy» 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 Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Conectarse a una base de datos con SQLAlchemy»?
Cree un motor de SQLAlchemy para SQLite y PostgreSQL y páselo a pd.read_sql para cargar una tabla en un DataFrame. Practicas Pandas & NumPy 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 Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy 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 1 de 4.
¿Cuánto tiempo toma la lección «Conectarse a una base de datos con SQLAlchemy»?
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 Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy 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
- Conectarse a una base de datos con SQLAlchemy
- Ejecutar consultas SQL desde Pandas
- Escribir DataFrames en tablas de bases de datos
- Pandas frente a SQL: cómo elegir la herramienta adecuada