Como Conectar Python a Bancos de Dados SQL e NoSQL

A manipulação de dados é uma das tarefas mais comuns e essenciais em qualquer aplicação. Python oferece ferramentas poderosas para se conectar a bancos de dados relacionais (SQL) e não relacionais (NoSQL), permitindo criar aplicações robustas, escaláveis e integradas.

Neste post, vamos explorar como conectar Python a diferentes tipos de bancos de dados, executar consultas, realizar inserções e atualizações, além de boas práticas para segurança e performance.

1. Conectando Python a bancos de dados SQL

Bancos de dados relacionais, como MySQL, PostgreSQL e SQLite, utilizam linguagem SQL para manipulação de dados. Python possui drivers e ORMs para facilitar a integração.

1.1 SQLite (embutido no Python)

SQLite é um banco de dados leve, sem servidor, ideal para protótipos e aplicações pequenas.

import sqlite3

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

# Criar tabela
cursor.execute('''CREATE TABLE IF NOT EXISTS usuarios (
                    id INTEGER PRIMARY KEY,
                    nome TEXT,
                    idade INTEGER)''')

# Inserir dados
cursor.execute("INSERT INTO usuarios (nome, idade) VALUES (?, ?)", ("Alice", 30))
conn.commit()

# Consultar dados
cursor.execute("SELECT * FROM usuarios")
for row in cursor.fetchall():
    print(row)

conn.close()

Vantagens:

Simples e rápido para testes
Não requer servidor externo
Ideal para scripts e aplicações pequenas

1.2 MySQL com `mysql-connector-python`

import mysql.connector

conn = mysql.connector.connect(
    host="localhost",
    user="root",
    password="senha",
    database="meubanco"
)

cursor = conn.cursor()
cursor.execute("SELECT * FROM clientes")
for row in cursor.fetchall():
    print(row)

conn.close()

Vantagens:

Suporte a transações
Integração com aplicações web e empresariais
Compatível com ORMs como SQLAlchemy

1.3 PostgreSQL com `psycopg2`

import psycopg2

conn = psycopg2.connect(
    host="localhost",
    database="meubanco",
    user="postgres",
    password="senha"
)

cursor = conn.cursor()
cursor.execute("SELECT * FROM pedidos")
for row in cursor.fetchall():
    print(row)

conn.close()

Vantagens:

Recursos avançados: JSON, índices, triggers
Performance em consultas complexas
Amplamente usado em aplicações corporativas

1.4 Usando ORMs: SQLAlchemy

SQLAlchemy permite trabalhar com objetos Python em vez de escrever SQL diretamente.

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

Base = declarative_base()

class Usuario(Base):
    __tablename__ = 'usuarios'
    id = Column(Integer, primary_key=True)
    nome = Column(String)
    idade = Column(Integer)

engine = create_engine('sqlite:///exemplo.db', echo=True)
Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

novo_usuario = Usuario(nome="Bob", idade=25)
session.add(novo_usuario)
session.commit()

for usuario in session.query(Usuario).all():
    print(usuario.nome, usuario.idade)

Vantagens:

Abstração do SQL
Fácil migração entre bancos
Suporte a relacionamentos complexos

2. Conectando Python a bancos de dados NoSQL

Bancos de dados NoSQL armazenam dados de forma não relacional, como documentos, chaves-valor ou grafos. Python oferece bibliotecas para interagir com os principais bancos NoSQL.

2.1 MongoDB com `pymongo`

from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db = client["meubanco"]
colecao = db["clientes"]

# Inserir documento
colecao.insert_one({"nome": "Alice", "idade": 30})

# Consultar documentos
for cliente in colecao.find():
    print(cliente)

# Atualizar documento
colecao.update_one({"nome": "Alice"}, {"$set": {"idade": 31}})

Vantagens:

Estrutura flexível em JSON
Ideal para aplicações dinâmicas
Suporte a consultas complexas e agregações

2.2 Redis (chave-valor) com `redis-py`

import redis

r = redis.Redis(host='localhost', port=6379, db=0)

# Inserir dados
r.set('usuario:1', 'Alice')

# Recuperar dados
print(r.get('usuario:1').decode())

Vantagens:

Extremamente rápido
Ideal para caching, filas e counters
Suporte a estruturas complexas: listas, sets, hashes

2.3 Cassandra com `cassandra-driver`

from cassandra.cluster import Cluster

cluster = Cluster(['127.0.0.1'])
session = cluster.connect('meubanco')

# Inserir dados
session.execute("INSERT INTO clientes (id, nome, idade) VALUES (1, 'Alice', 30)")

# Consultar dados
rows = session.execute("SELECT * FROM clientes")
for row in rows:
    print(row.nome, row.idade)

Vantagens:

Bancos distribuídos e escaláveis
Alta disponibilidade e tolerância a falhas
Ideal para big data e aplicações massivas

3. Boas práticas ao conectar Python a bancos de dados

Use conexões seguras: SSL, autenticação e senhas criptografadas
Gerencie conexões: use with ou pools de conexão para evitar vazamento de recursos
Trate erros de conexão: try-except para falhas e reconexões
Valide entradas: evite injeção de SQL/NoSQL
Use transações quando necessário: para operações críticas
Mantenha abstração com ORMs: facilita migração e manutenção
Cache de consultas frequentes: Redis ou Memcached para reduzir carga no banco
Escalabilidade: considere bancos distribuídos ou sharding para grandes volumes

4. Integração SQL + NoSQL

Muitas aplicações modernas combinam bancos relacionais e não relacionais:

SQL para dados estruturados e transacionais
NoSQL para dados semi-estruturados ou alto volume
Python facilita integração via camadas de abstração e bibliotecas compatíveis

Exemplo:

PostgreSQL para cadastro de usuários
MongoDB para logs de atividades
Redis para sessões e cache

5. Conclusão

Python é uma ferramenta poderosa para conectar, manipular e integrar bancos de dados SQL e NoSQL. Com o uso de:

Drivers nativos (sqlite3, psycopg2, pymongo, redis-py)
ORMs e abstrações (SQLAlchemy)
Boas práticas de segurança e performance

é possível criar aplicações escaláveis, seguras e eficientes, aproveitando o melhor de cada tipo de banco de dados.

Pesquisar este blog

The Master Coder