15 Banco de Dados SQL com Python

De pilha de papéis para biblioteca organizada: estruturando seus dados!

15.1 O que você vai aprender neste capítulo?

Por que usar bancos de dados em vez de arquivos simples
SQL básico: comandos essenciais (CREATE, INSERT, SELECT, UPDATE, DELETE)
SQLite com Python: como usar a biblioteca sqlite3 integrada
Operações CRUD: criar, ler, atualizar e deletar dados
Consultas avançadas: WHERE, ORDER BY, LIMIT e JOINs básicos
Projeto prático: sistema completo de cadastro de clientes
Boas práticas: prevenção de SQL Injection e gerenciamento de conexões
Integração: conectar bancos de dados com APIs e web scraping

🎓 Vindo do Capítulo 14? Perfeito! Agora que você sabe coletar dados da web, vamos organizar esses dados!

🎯 Meta: Ao final deste capítulo, você vai conseguir criar e gerenciar bancos de dados SQL, executar consultas e integrar dados com aplicações Python.

⚠️ Por que isso importa: Bancos de dados são fundamentais para aplicações reais! Sem eles, você perderia dados toda vez que fechasse o programa. Aqui você aprende a criar sistemas persistentes!

15.2 De Pilha de Papéis para Biblioteca Organizada

15.2.1 Analogia Perfeita: Biblioteca vs. Pilha de Papéis

Problema - Pilha de Papéis:

📄 Todos os documentos em uma pilha
🔍 Difícil encontrar algo específico
📊 Impossível fazer análises
💥 Fácil perder ou danificar
👥 Muitas pessoas não conseguem usar

Solução - Biblioteca Organizada:

📚 Livros organizados por categoria
🔍 Sistema de busca eficiente
📊 Relatórios e estatísticas
🛡️ Proteção contra perda
👥 Muitas pessoas podem usar simultaneamente

15.2.2 Por que usar Bancos de Dados?

Sem banco de dados (problema):

# Dados em memória - perdidos quando programa fecha
clientes = [
    {'nome': 'João', 'email': 'joao@email.com'},
    {'nome': 'Maria', 'email': 'maria@email.com'}
]

# Dados em arquivo - difícil de consultar
with open('clientes.txt', 'w') as f:
    f.write('João,joao@email.com\nMaria,maria@email.com\n')

Com banco de dados (solução):

# Dados persistentes e organizados
# Fácil de consultar, atualizar e analisar
# Múltiplos usuários podem acessar
# Dados protegidos e consistentes

15.2.3 O que é SQL?

SQL (Structured Query Language) é a linguagem para conversar com bancos de dados.

É como falar com o bibliotecário:

📖 “Mostre todos os livros de Python”
➕ “Adicione um novo livro”
✏️ “Atualize o preço deste livro”
🗑️ “Remova este livro antigo”

15.2.4 SQLite - Banco de Dados Simples

SQLite é perfeito para aprender:

✅ Simples: Um arquivo = um banco
✅ Integrado: Já vem com Python
✅ Rápido: Ideal para aplicações pequenas/médias
✅ Portável: Funciona em qualquer lugar

💡 Exemplo: WhatsApp, Instagram e muitos apps usam SQLite para armazenar dados localmente!

15.3 Seu Primeiro Banco de Dados

15.3.1 Criando e Conectando ao Banco

import sqlite3

# Conectar ao banco (cria se não existir)
conn = sqlite3.connect('meu_banco.db')
cursor = conn.cursor()

print("✅ Conectado ao banco de dados!")

# Sempre fechar a conexão
conn.close()

15.3.2 Criando sua Primeira Tabela

import sqlite3

def criar_tabela_clientes():
    """Cria tabela de clientes"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
# Criar tabela
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS clientes (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nome TEXT NOT NULL,
            email TEXT UNIQUE,
            idade INTEGER,
            cidade TEXT
        )
    ''')
    
# Salvar mudanças
    conn.commit()
    conn.close()
    print("✅ Tabela 'clientes' criada!")

# Executar
criar_tabela_clientes()

15.3.3 Inserindo Dados (INSERT)

def inserir_cliente(nome, email, idade, cidade):
    """Insere um novo cliente"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
    try:
        cursor.execute('''
            INSERT INTO clientes (nome, email, idade, cidade)
            VALUES (?, ?, ?, ?)
        ''', (nome, email, idade, cidade))
        
        conn.commit()
        print(f"✅ Cliente '{nome}' inserido com sucesso!")
        
    except sqlite3.IntegrityError:
        print(f"❌ Email '{email}' já existe!")
    
    finally:
        conn.close()

# Testando
inserir_cliente('João Silva', 'joao@email.com', 30, 'São Paulo')
inserir_cliente('Maria Santos', 'maria@email.com', 25, 'Rio de Janeiro')
inserir_cliente('Pedro Costa', 'pedro@email.com', 35, 'Belo Horizonte')

15.3.4 Consultando Dados (SELECT)

def listar_clientes():
    """Lista todos os clientes"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
    cursor.execute('SELECT * FROM clientes')
    clientes = cursor.fetchall()
    
    print("📋 Lista de Clientes:")
    print("-" * 50)
    for cliente in clientes:
        print(f"ID: {cliente[0]} | Nome: {cliente[1]} | Email: {cliente[2]} | Idade: {cliente[3]} | Cidade: {cliente[4]}")
    
    conn.close()
    return clientes

# Testando
listar_clientes()

15.3.5 Consultas com Filtros (WHERE)

def buscar_cliente_por_cidade(cidade):
    """Busca clientes por cidade"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
    cursor.execute('SELECT * FROM clientes WHERE cidade = ?', (cidade,))
    clientes = cursor.fetchall()
    
    print(f"🏙️ Clientes de {cidade}:")
    for cliente in clientes:
        print(f"- {cliente[1]} ({cliente[2]})")
    
    conn.close()
    return clientes

def buscar_clientes_maiores_que(idade_minima):
    """Busca clientes maiores que uma idade"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
    cursor.execute('SELECT nome, idade FROM clientes WHERE idade > ?', (idade_minima,))
    clientes = cursor.fetchall()
    
    print(f"👴 Clientes maiores que {idade_minima} anos:")
    for cliente in clientes:
        print(f"- {cliente[0]} ({cliente[1]} anos)")
    
    conn.close()
    return clientes

# Testando
buscar_cliente_por_cidade('São Paulo')
buscar_clientes_maiores_que(30)

💡 Dica: Use ? placeholders para evitar SQL Injection! Nunca concatene strings diretamente no SQL.

15.4 Atualizando e Deletando Dados

15.4.1 Atualizando Dados (UPDATE)

def atualizar_cliente(cliente_id, novo_nome=None, novo_email=None, nova_idade=None, nova_cidade=None):
    """Atualiza dados de um cliente"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
# Construir query dinamicamente
    campos = []
    valores = []
    
    if novo_nome:
        campos.append('nome = ?')
        valores.append(novo_nome)
    if novo_email:
        campos.append('email = ?')
        valores.append(novo_email)
    if nova_idade:
        campos.append('idade = ?')
        valores.append(nova_idade)
    if nova_cidade:
        campos.append('cidade = ?')
        valores.append(nova_cidade)
    
    if campos:
        valores.append(cliente_id)
        query = f"UPDATE clientes SET {', '.join(campos)} WHERE id = ?"
        
        cursor.execute(query, valores)
        conn.commit()
        print(f"✅ Cliente ID {cliente_id} atualizado!")
    else:
        print("❌ Nenhum campo para atualizar!")
    
    conn.close()

# Testando
atualizar_cliente(1, novo_nome='João Silva Santos', nova_idade=31)

15.4.2 Deletando Dados (DELETE)

def deletar_cliente(cliente_id):
    """Deleta um cliente pelo ID"""
    conn = sqlite3.connect('loja.db')
    cursor = conn.cursor()
    
# Verificar se cliente existe
    cursor.execute('SELECT nome FROM clientes WHERE id = ?', (cliente_id,))
    cliente = cursor.fetchone()
    
    if cliente:
        cursor.execute('DELETE FROM clientes WHERE id = ?', (cliente_id,))
        conn.commit()
        print(f"✅ Cliente '{cliente[0]}' deletado!")
    else:
        print(f"❌ Cliente ID {cliente_id} não encontrado!")
    
    conn.close()

# Testando
deletar_cliente(3)  # Deletar Pedro Costa

15.4.3 Sistema Completo de Gerenciamento

class GerenciadorClientes:
    """Classe para gerenciar clientes no banco de dados"""
    
    def __init__(self, nome_banco='loja.db'):
        self.nome_banco = nome_banco
        self.criar_tabela()
    
    def conectar(self):
        """Conecta ao banco de dados"""
        return sqlite3.connect(self.nome_banco)
    
    def criar_tabela(self):
        """Cria tabela se não existir"""
        conn = self.conectar()
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS clientes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nome TEXT NOT NULL,
                email TEXT UNIQUE,
                idade INTEGER,
                cidade TEXT,
                data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def adicionar_cliente(self, nome, email, idade, cidade):
        """Adiciona novo cliente"""
        conn = self.conectar()
        cursor = conn.cursor()
        
        try:
            cursor.execute('''
                INSERT INTO clientes (nome, email, idade, cidade)
                VALUES (?, ?, ?, ?)
            ''', (nome, email, idade, cidade))
            
            conn.commit()
            print(f"✅ Cliente '{nome}' adicionado!")
            return True
            
        except sqlite3.IntegrityError:
            print(f"❌ Email '{email}' já existe!")
            return False
        finally:
            conn.close()
    
    def listar_clientes(self):
        """Lista todos os clientes"""
        conn = self.conectar()
        cursor = conn.cursor()
        
        cursor.execute('SELECT * FROM clientes ORDER BY nome')
        clientes = cursor.fetchall()
        
        print("📋 Lista de Clientes:")
        print("-" * 80)
        for cliente in clientes:
            print(f"ID: {cliente[0]:2} | Nome: {cliente[1]:20} | Email: {cliente[2]:25} | Idade: {cliente[3]:2} | Cidade: {cliente[4]}")
        
        conn.close()
        return clientes
    
    def buscar_cliente(self, termo):
        """Busca cliente por nome ou email"""
        conn = self.conectar()
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT * FROM clientes 
            WHERE nome LIKE ? OR email LIKE ?
        ''', (f'%{termo}%', f'%{termo}%'))
        
        clientes = cursor.fetchall()
        
        if clientes:
            print(f"🔍 Resultados para '{termo}':")
            for cliente in clientes:
                print(f"- {cliente[1]} ({cliente[2]}) - {cliente[4]}")
        else:
            print(f"❌ Nenhum cliente encontrado para '{termo}'")
        
        conn.close()
        return clientes
    
    def estatisticas(self):
        """Mostra estatísticas dos clientes"""
        conn = self.conectar()
        cursor = conn.cursor()
        
# Total de clientes
        cursor.execute('SELECT COUNT(*) FROM clientes')
        total = cursor.fetchone()[0]
        
# Média de idade
        cursor.execute('SELECT AVG(idade) FROM clientes WHERE idade IS NOT NULL')
        media_idade = cursor.fetchone()[0]
        
# Clientes por cidade
        cursor.execute('SELECT cidade, COUNT(*) FROM clientes GROUP BY cidade ORDER BY COUNT(*) DESC')
        cidades = cursor.fetchall()
        
        print("📊 Estatísticas dos Clientes:")
        print("-" * 40)
        print(f"Total de clientes: {total}")
        if media_idade:
            print(f"Média de idade: {media_idade:.1f} anos")
        print("\nClientes por cidade:")
        for cidade, count in cidades:
            print(f"- {cidade}: {count} clientes")
        
        conn.close()

# Testando o sistema completo
gerenciador = GerenciadorClientes()

# Adicionar alguns clientes
gerenciador.adicionar_cliente('Ana Costa', 'ana@email.com', 28, 'São Paulo')
gerenciador.adicionar_cliente('Carlos Lima', 'carlos@email.com', 42, 'Rio de Janeiro')
gerenciador.adicionar_cliente('Fernanda Silva', 'fernanda@email.com', 33, 'São Paulo')

# Listar clientes
gerenciador.listar_clientes()

# Buscar cliente
gerenciador.buscar_cliente('Ana')

# Mostrar estatísticas
gerenciador.estatisticas()

💡 Parabéns! Você criou um sistema completo de gerenciamento de dados com banco de dados SQL!

15.5 Exercícios Práticos

15.5.1 MUITO FÁCIL (Nível 1)

1. Crie uma tabela livros com campos: id, titulo, autor, ano, preco.

2. Insira 3 livros na tabela criada no exercício anterior.

3. Liste todos os livros da tabela.

4. Busque livros de um autor específico.

5. Conte quantos livros existem na tabela.

15.5.2 FÁCIL (Nível 2)

6. Crie um sistema de cadastro de alunos com nome, matrícula, curso e nota.

7. Implemente funções para adicionar, listar e buscar alunos.

8. Crie uma tabela de produtos com nome, categoria, preço e estoque.

9. Implemente um sistema de vendas que registra produtos vendidos.

10. Crie consultas para encontrar produtos com estoque baixo (< 10).

15.5.3 MÉDIO (Nível 3)

11. Crie um sistema de biblioteca com livros, usuários e empréstimos.

12. Implemente um sistema de notas escolares com alunos, disciplinas e notas.

13. Crie um sistema de e-commerce com produtos, clientes e pedidos.

14. Implemente um sistema de agenda com contatos e categorias.

15. Crie um sistema de controle de estoque com produtos e movimentações.

15.5.4 DIFÍCIL (Nível 4)

16. Crie um sistema de rede social com usuários, posts e comentários.

17. Implemente um sistema bancário com contas, transações e extratos.

18. Crie um sistema de hotel com quartos, hóspedes e reservas.

19. Implemente um sistema de escola com alunos, professores e disciplinas.

20. Crie um sistema de delivery com restaurantes, pedidos e entregadores.

15.5.5 MUITO DIFÍCIL (Nível 5)

21. Crie um sistema completo de marketplace com vendedores e compradores.

22. Implemente um sistema de streaming com usuários, conteúdo e assinaturas.

23. Crie um sistema de saúde com pacientes, médicos e consultas.

24. Implemente um sistema de transporte com rotas, passageiros e viagens.

25. Crie um sistema de IoT que armazena dados de sensores em tempo real.

🎯 Dica: Comece com tabelas simples e vá adicionando complexidade gradualmente. Sempre teste suas consultas SQL!