Conectando-se a um banco de dados com SQLAlchemy
Crie um mecanismo SQLAlchemy para SQLite e PostgreSQL e passe-o a pd.read_sql para carregar uma tabela em um DataFrame.
Conectando-se a um banco de dados com SQLAlchemy é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 1 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 Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
Por que conectar o Pandas a bancos de dados?
A maior parte dos dados de produção está em bancos de dados relacionais — PostgreSQL, MySQL, SQLite ou SQL Server — e não em arquivos CSV. Conectar o Pandas diretamente a um banco de dados permite consultar dados para um DataFrame sem exportá-los primeiro para CSV, enviar DataFrames limpos de volta para tabelas e combinar o poder analítico do Python com os recursos de indexação e junção do banco de dados. A ponte entre o Pandas e os bancos de dados é o SQLAlchemy, a biblioteca padrão de abstração de bancos de dados do Python.
Instalando o SQLAlchemy
O SQLAlchemy é um kit de ferramentas SQL e um ORM para Python. Para a integração com o Pandas, você precisa apenas da camada Core, não do ORM. Instale-o com pip install sqlalchemy. Você também precisa do driver específico do banco de dados: psycopg2 para PostgreSQL, pymysql para MySQL ou sqlite3 (incluído no Python) para SQLite. O SQLAlchemy atua como uma camada de abstração: o mesmo código do Pandas funciona com qualquer banco de dados compatível, alterando apenas a cadeia de conexão.
# 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__)Criando um mecanismo de conexão
O primeiro passo é criar um mecanismo do SQLAlchemy usando uma URL de conexão que codifica o tipo de banco de dados, as credenciais, o servidor, a porta e o nome do banco de dados. O mecanismo é uma fábrica de conexões de banco de dados: ele não abre uma conexão até que você realmente precise de uma. Passe o mecanismo para as funções pd.read_sql() e df.to_sql() do Pandas. Nunca inclua credenciais diretamente no código; leia-as de variáveis de ambiente ou de um gerenciador de segredos.
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))Lendo uma tabela com pd.read_sql_table()
pd.read_sql_table('table_name', con=engine) lê uma tabela inteira do banco de dados para um DataFrame. Ele infere automaticamente os tipos de dados das colunas a partir do esquema do banco: inteiros continuam sendo inteiros, marcas de tempo continuam sendo datas e horas etc. Isso é mais preciso do que a inferência feita a partir de CSV. Você também pode limitar as colunas com o argumento columns e filtrar as linhas com schema para esquemas de banco de dados que não sejam o padrão. Tenha cuidado com tabelas muito grandes: isso carrega tudo na 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())Executando consultas com pd.read_sql_query()
pd.read_sql_query('SELECT ...', con=engine) executa uma instrução SQL SELECT arbitrária e retorna os resultados como um DataFrame. Esta é a abordagem mais flexível: você pode filtrar, fazer junções e agregar dados em SQL antes de carregá-los no Pandas, carregando apenas as linhas e colunas necessárias. Escreva a consulta como uma cadeia de caracteres simples do Python. Nunca concatene dados fornecidos pelo usuário às consultas; use consultas parametrizadas para evitar injeção de 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 segurança
Nunca crie consultas SQL concatenando cadeias de caracteres com valores fornecidos pelo usuário, pois isso abre vulnerabilidades de injeção de SQL. Em vez disso, use consultas parametrizadas: passe os parâmetros como um dicionário com marcadores nomeados. O SQLAlchemy trata do escape dos valores. A sintaxe dos marcadores é :name nas consultas de texto do SQLAlchemy ou %(name)s nas consultas no estilo do psycopg2. Use sempre a parametrização, mesmo em scripts internos, para desenvolver bons 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')Processando grandes resultados de consultas em partes
Para resultados grandes de consultas, use chunksize em pd.read_sql_query() para receber um iterador de DataFrames em vez de carregar tudo de uma vez. Isso funciona de modo semelhante a pd.read_csv(chunksize=...), mas busca as linhas do banco de dados em lotes. Combine essa abordagem com um padrão de acumulador contínuo para agregar resultados de consultas com milhões de linhas sem esgotar a 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}')Gerenciadores de contexto para conexões
Sempre abra conexões de banco de dados dentro de um gerenciador de contexto (with engine.connect() as conn:) para garantir que a conexão seja fechada corretamente, mesmo que ocorra uma exceção. Esquecer de fechar as conexões causa esgotamento do conjunto de conexões em produção, fazendo com que novas consultas fiquem bloqueadas à espera de uma vaga. O conjunto de conexões do SQLAlchemy gerencia um número fixo de conexões e as reutiliza automaticamente quando gerenciadores de contexto são usados.
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 hereInspecionando o esquema do banco de dados
Antes de escrever consultas, você precisa saber quais tabelas e colunas existem. O Inspector do SQLAlchemy permite refletir o esquema do banco de dados sem escrever SQL bruto. inspector.get_table_names() lista todas as tabelas; inspector.get_columns('table') retorna os nomes e tipos das colunas. Isso é útil ao trabalhar com bancos de dados desconhecidos e é mais limpo do que executar manualmente PRAGMA table_info() ou \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"]}')Fechando mecanismos e boas práticas
Em scripts de longa duração ou aplicações web, chame engine.dispose() quando terminar para fechar todas as conexões do conjunto. Em scripts curtos, o coletor de lixo do Python cuida da limpeza. Boas práticas para conexões de banco de dados em fluxos de dados: crie o mecanismo uma única vez no início do script e reutilize-o; use os padrões de agrupamento de conexões (pool_size=5); ative pool_pre_ping=True para reconectar automaticamente se o servidor do banco de dados for reiniciado entre as 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')Comparando a velocidade de read_sql e read_csv
Para dados que já estão em um banco de dados com índices adequados, pd.read_sql_query com uma consulta filtrada costuma ser mais rápido do que exportar para CSV e ler o arquivo. O servidor do banco de dados aplica os filtros antes de enviar os dados, reduzindo a transferência pela rede e o custo de análise. Para tabelas muito largas, o banco também pode selecionar apenas as colunas necessárias. No entanto, ler dados de um banco remoto por uma rede lenta pode ser mais demorado do que ler um arquivo Parquet local — sempre avalie as duas opções no seu ambiente específico.
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')Verificação rápida
Teste sua compreensão dos conceitos de Análise de Dados desta lição.
Recapitulação da lição
Nesta lição, você aprendeu que sa.create_engine() cria uma fábrica de conexões reutilizável a partir de uma cadeia de caracteres de URL; que pd.read_sql_query() executa SQL arbitrário e retorna um DataFrame; e que consultas parametrizadas com sa.text() e params evitam vulnerabilidades de injeção de SQL. A seguir, veremos como executar consultas SQL mais complexas a partir do Pandas e combinar SQL com a lógica do Python.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Conectando-se a um banco de dados com SQLAlchemy” é grátis?
Sim — o texto completo de “Conectando-se a um banco de dados com SQLAlchemy” é 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 Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Conectando-se a um banco de dados com SQLAlchemy”?
Crie um mecanismo SQLAlchemy para SQLite e PostgreSQL e passe-o a pd.read_sql para carregar uma tabela em um DataFrame. Você pratica Pandas & NumPy 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 Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy 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 1 de 4.
Quanto tempo leva a aula “Conectando-se a um banco de dados com SQLAlchemy”?
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 Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy 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
- Conectando-se a um banco de dados com SQLAlchemy
- Executando consultas SQL no Pandas
- Gravando DataFrames em tabelas de banco de dados
- Pandas vs. SQL: escolhendo a ferramenta certa