Resumo Universitario_ Integracao Python e SQL

Prévia do material em texto

Resumo Integração Python e SQL 
Disciplina: Banco de Dados / Linguagem de Programação 
Nível: Universitário / Profissional 
Foco: Arquitetura, Prática e Segurança 
1. Definição e Cenário 
A integração entre Python e Bancos de Dados Relacionais (SQL) permite que aplicações 
manipulem dados persistentes de forma programática. 
● O que é: Conectar um script Python a um SGBD (Sistema Gerenciador de Banco de 
Dados) para enviar comandos SQL e receber resultados. 
● Para que serve: Back-ends de sites (Django/Flask), Automação de relatórios, Ciência 
de Dados (ETL) e Sistemas ERP. 
● Como funciona: O Python não fala "nativo" com o banco. Ele precisa de um tradutor 
chamado Driver ou Conector. 
🖼 Sugestão de Imagem/Diagrama: 
Um diagrama de blocos simples: 
[Código Python] [API (Driver)] [SGBD (Postgres/MySQL)] 
2. A Arquitetura Padrão: DB-API 2.0 (PEP 249) 
A maioria dos drivers Python segue uma norma chamada PEP 249. Isso garante que o código 
para conectar no MySQL seja quase idêntico ao do PostgreSQL. 
Conceitos Chave (O "Vocabulário") 
1. Connection (Conexão): É a estrada. Representa a sessão aberta com o banco. 
2. Cursor: É o veículo. Objeto usado para executar comandos e percorrer os resultados. 
3. Query (Consulta): O comando SQL (string) enviado. 
4. Transaction (Transação): O conjunto de mudanças. Só se tornam reais após o commit. 
Principais Drivers (Bibliotecas) 
Banco de Dados Biblioteca Comum Comando de Instalação 
PostgreSQL psycopg2 pip install psycopg2-binary 
MySQL/MariaDB mysql-connector-python pip install 
mysql-connector-python 
SQLite sqlite3 (Nativo, já vem no Python) 
SQL Server pyodbc pip install pyodbc 
3. Fluxo de Trabalho "Raw SQL" (Baixo Nível) 
Este é o método clássico, usando SQL puro dentro do Python. 
Passo a Passo Obrigatório: 
1. Importar o driver. 
2. Criar a Conexão (connect). 
3. Criar o Cursor (cursor). 
4. Executar SQL (execute). 
5. Persistir (commit) ou Buscar Dados (fetch). 
6. Fechar Cursor e Conexão (close). 
💻 Exemplo Prático (Padrão de Prova) 
import sqlite3 
 
# 1. Conexão (cria o arquivo se não existir) 
conn = sqlite3.connect('exemplo_universidade.db') 
 
# 2. Criar Cursor 
cursor = conn.cursor() 
 
# 3. Executar (Criar tabela) 
cursor.execute(''' 
 CREATE TABLE IF NOT EXISTS alunos ( 
 id INTEGER PRIMARY KEY, 
 nome TEXT, 
 nota REAL 
 ) 
''') 
 
# 4. Inserir Dados (COM SEGURANÇA - Veja ponto 5) 
# Usamos '?' como placeholder para evitar SQL Injection 
cursor.execute("INSERT INTO alunos (nome, nota) VALUES (?, ?)", ('Ana', 9.5)) 
 
# 5. Commit (Salvar alterações no disco) 
conn.commit() 
 
# 6. Consultar (Select) 
cursor.execute("SELECT * FROM alunos") 
resultados = cursor.fetchall() # Traz tudo como uma lista de tuplas 
 
for aluno in resultados: 
 print(aluno) # Saída: (1, 'Ana', 9.5) 
 
# 7. Fechar 
conn.close() 
 
4. ORMs: O Nível Avançado (SQLAlchemy) 
Em sistemas grandes, evitar escrever SQL manual é preferível. Usamos ORM 
(Object-Relational Mapping). 
● Conceito: Transforma Classes Python em Tabelas SQL. 
● Vantagem: Abstração (troca de banco fácil), código mais limpo. 
● Desvantagem: Ligeiramente mais lento que SQL puro (overhead). 
🖼 Sugestão de Imagem: 
Um desenho mostrando um espelho: 
De um lado class Aluno(Model): refletindo no espelho como CREATE TABLE aluno.... 
5. Pandas: A Visão de Análise de Dados 
Para cientistas de dados, não usamos cursores linha por linha. Carregamos tudo na memória. 
● Leitura: pd.read_sql(query, connection) 
● Escrita: df.to_sql('tabela', connection) 
Exemplo rápido: 
import pandas as pd 
import sqlite3 
 
conn = sqlite3.connect('exemplo.db') 
df = pd.read_sql("SELECT * FROM alunos WHERE nota > 7", conn) 
print(df.head()) # Mostra tabela formatada 
 
⚠ 6. O QUE MAIS CAI EM PROVA (Pontos de Atenção) 
A. SQL Injection (Segurança) 
É o erro número 1 em provas e entrevistas. 
● O Erro: Usar f-strings ou concatenação de strings para colocar valores na query. 
○ Errado: cursor.execute(f"SELECT * FROM users WHERE id = {user_id}") 
● O Correto: Usar Parameterized Queries (Placeholders). 
○ Certo: cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,)) 
● Por que? O driver trata a entrada como dado literal, impedindo que comandos 
maliciosos sejam executados. 
B. Commit vs. Rollback (Transações ACID) 
● Se você fizer INSERT, UPDATE ou DELETE e esquecer do conn.commit(), nada será 
salvo. 
● Se der erro no meio do processo, usa-se conn.rollback() para desfazer tudo e garantir a 
integridade. 
C. Fetchone vs. Fetchall 
● fetchone(): Traz a próxima linha (tupla). Bom para loops gigantes (economia de 
memória). 
● fetchall(): Traz TUDO para uma lista. Perigoso se a tabela tiver 1 milhão de linhas 
(estoura a RAM). 
7. Quadro Resumo Final 
Característica Driver Nativo (Raw 
SQL) 
ORM (SQLAlchemy) Pandas 
Uso Principal Scripts simples, 
Performance máxima 
Web Apps, Sistemas 
Complexos 
Análise de Dados, ETL 
Curva de 
Aprendizado 
Baixa (Se souber SQL) Média/Alta Baixa 
Segurança Depende do 
programador 
(Placeholders) 
Alta (Automática) Alta 
Código SQL Explícito (Você 
escreve) 
Implícito (Gera 
automático) 
Mínimo 
💡 Dica de Ouro: 
Em provas teóricas, sempre cite a PEP 249 como base da padronização e mencione a 
importância de fechar conexões (conn.close()) para não vazar recursos do servidor. 
	Resumo Integração Python e SQL 
	1. Definição e Cenário 
	2. A Arquitetura Padrão: DB-API 2.0 (PEP 249) 
	Conceitos Chave (O "Vocabulário") 
	Principais Drivers (Bibliotecas) 
	3. Fluxo de Trabalho "Raw SQL" (Baixo Nível) 
	💻 Exemplo Prático (Padrão de Prova) 
	4. ORMs: O Nível Avançado (SQLAlchemy) 
	5. Pandas: A Visão de Análise de Dados 
	⚠️ 6. O QUE MAIS CAI EM PROVA (Pontos de Atenção) 
	A. SQL Injection (Segurança) 
	B. Commit vs. Rollback (Transações ACID) 
	C. Fetchone vs. Fetchall 
	7. Quadro Resumo Final