Arquivo de Declarativa - Área de Trampo

SQLAlchemy: Trabalhando com Bancos de Dados em Python

25/04/202623/04/2026 Por antonino

– Python
– Declarativa
1 – SQLAlchemy (ORM)
2 – Django Models
3 – List/dict comprehensions
4 – Regex (expressões regulares)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

SQLAlchemy é o ORM mais popular do ecossistema Python. ORM significa Mapeamento Objeto-Relacional. Ele traduz tabelas do banco em classes Python. Linhas das tabelas viram instâncias dessas classes. Primeiramente, isso elimina a necessidade de SQL puro. Você interage com o banco usando objetos familiares. Por exemplo, session.query(Usuario).filter_by(nome="Ana"). Isso é muito mais intuitivo que strings SQL. Além disso, o SQLAlchemy é compatível com vários bancos. PostgreSQL, MySQL, SQLite e Oracle são suportados. Portanto, você troca de banco sem reescrever tudo. Assim, a produtividade do desenvolvedor aumenta drasticamente.

Características fundamentais do SQLAlchemy

SQLAlchemy tem duas camadas principais: Core e ORM. A camada Core fornece acesso SQL de baixo nível. Ela é útil para consultas complexas e otimizadas. A camada ORM é mais abstrata e amigável. Ela foi projetada para produtividade do dia a dia. Outra característica importante é o lazy loading. Relacionamentos são carregados sob demanda automaticamente. Isso evita consultas desnecessárias ao banco. Além disso, o SQLAlchemy protege contra injeção de SQL. As consultas são parametrizadas automaticamente. Consequentemente, a segurança é significativamente melhor. Uma fórmula que representa isso é:

\(\text{SQLAlchemy} = \text{Abstração} + \text{Segurança} – \text{SQL manual}\)

Portanto, você ganha tempo e reduz riscos.

Outro ponto forte é a migração de esquemas. A biblioteca Alembic integra-se perfeitamente com ela. Você pode evoluir seu banco de forma versionada. Isso é essencial para equipes em produção. Primeiramente, defina seus modelos em Python puro. Depois, gere as migrações automaticamente. Assim, todos os ambientes ficam sincronizados.

Quando utilizar SQLAlchemy no seu projeto

Use SQLAlchemy em aplicações web com banco de dados. Frameworks como Flask e Django o suportam bem. Também é ideal para APIs REST que persistem dados. Projetos de médio a grande porte se beneficiam mais. Por outro lado, evite ORM para scripts muito simples. Uma única consulta SQL direta pode ser mais rápida. Além disso, não use para análises de dados pesadas. Nesse caso, pandas é a ferramenta mais adequada. Primeiramente, avalie a complexidade das suas queries. Se você tem muitos joins e relações, ORM é ótimo. Se são consultas simples, o SQL puro resolve bem. Portanto, a escolha depende do seu contexto específico.

Outro bom uso é em projetos com equipes grandes. O ORM padroniza o acesso ao banco de dados. Novos desenvolvedores aprendem mais rapidamente. Isso foi observado em muitas empresas de sucesso. Use SQLAlchemy também quando a portabilidade importa. Trocar de PostgreSQL para MySQL é simples. Assim, você evita o lock-in com fornecedores. Portanto, SQLAlchemy é uma escolha profissional.

Exemplo prático: modelo de usuários e posts

O código abaixo implementa um blog simples. Temos duas tabelas: Usuario e Post. Um usuário pode ter muitos posts (relação 1:N). Primeiramente, definimos as classes com declarative_base. Depois, configuramos a conexão com SQLite em memória. Criamos as tabelas automaticamente com create_all. Por fim, inserimos dados e fazemos consultas. Observe como não escrevemos nenhuma linha de SQL. Tudo é feito através de objetos Python familiares. Isso é o poder do mapeamento objeto-relacional. Vamos ao código comentado para detalhes.

# Instalação: pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, DateTime
from sqlalchemy.orm import declarative_base, sessionmaker, relationship
from datetime import datetime

# ============================================
# MODELOS (DEFINIÇÃO DAS TABELAS)
# ============================================

Base = declarative_base()

class Usuario(Base):
    __tablename__ = 'usuarios'
    
    id = Column(Integer, primary_key=True)
    nome = Column(String(100), nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    data_cadastro = Column(DateTime, default=datetime.now)
    
    # Relacionamento: um usuário tem muitos posts
    posts = relationship("Post", back_populates="autor", cascade="all, delete-orphan")
    
    def __repr__(self):
        return f"<Usuario(id={self.id}, nome='{self.nome}', email='{self.email}')>"


class Post(Base):
    __tablename__ = 'posts'
    
    id = Column(Integer, primary_key=True)
    titulo = Column(String(200), nullable=False)
    conteudo = Column(String, nullable=False)
    data_publicacao = Column(DateTime, default=datetime.now)
    usuario_id = Column(Integer, ForeignKey('usuarios.id'))
    
    # Relacionamento: o post pertence a um usuário
    autor = relationship("Usuario", back_populates="posts")
    
    def __repr__(self):
        return f"<Post(id={self.id}, titulo='{self.titulo}', autor_id={self.usuario_id})>"


# ============================================
# CONFIGURAÇÃO DO BANCO
# ============================================

# Conectando ao SQLite (em memória para exemplo)
engine = create_engine('sqlite:///:memory:', echo=True)
# Para arquivo real: 'sqlite:///meubanco.db'
# Para PostgreSQL: 'postgresql://user:pass@localhost/db'

# Cria todas as tabelas definidas
Base.metadata.create_all(engine)

# Cria uma fábrica de sessões
Session = sessionmaker(bind=engine)
session = Session()


# ============================================
# OPERAÇÕES CRUD (CREATE, READ, UPDATE, DELETE)
# ============================================

print("=== 1. CRIANDO USUÁRIOS ===")
usuario1 = Usuario(nome="Ana Silva", email="ana@email.com")
usuario2 = Usuario(nome="Carlos Oliveira", email="carlos@email.com")
usuario3 = Usuario(nome="Beatriz Santos", email="beatriz@email.com")

# Adicionando à sessão
session.add_all([usuario1, usuario2, usuario3])
session.commit()  # Salva no banco

print(f"Usuários criados: {usuario1}, {usuario2}, {usuario3}")


print("\n=== 2. CRIANDO POSTS ===")
post1 = Post(titulo="Primeiro post", conteudo="Conteúdo do primeiro post", autor=usuario1)
post2 = Post(titulo="SQLAlchemy é incrível", conteudo="Aprendendo ORM em Python", autor=usuario1)
post3 = Post(titulo="Dicas de Python", conteudo="List comprehensions são úteis", autor=usuario2)

session.add_all([post1, post2, post3])
session.commit()

print(f"Posts criados: {post1}, {post2}, {post3}")


print("\n=== 3. CONSULTANDO DADOS ===")
# Buscar todos os usuários
todos_usuarios = session.query(Usuario).all()
print(f"Todos usuários: {todos_usuarios}")

# Filtrar por condição
usuario_ana = session.query(Usuario).filter(Usuario.nome == "Ana Silva").first()
print(f"Usuário encontrado pelo nome: {usuario_ana}")

# Filtrar por email (campo único)
usuario_carlos = session.query(Usuario).filter_by(email="carlos@email.com").first()
print(f"Usuário encontrado por email: {usuario_carlos}")

# Consultar posts de um usuário específico
posts_ana = usuario_ana.posts
print(f"Posts de Ana: {posts_ana}")


print("\n=== 4. ATUALIZANDO DADOS ===")
# Atualizar um usuário
usuario_carlos.nome = "Carlos Alberto Oliveira"
session.commit()
print(f"Usuário atualizado: {usuario_carlos}")

# Atualizar um post
post2.titulo = "SQLAlchemy ORM - Guia Completo"
session.commit()
print(f"Post atualizado: {post2}")


print("\n=== 5. DELETANDO DADOS ===")
# Deletar um post
session.delete(post3)
session.commit()
print(f"Post {post3.id} deletado!")

# Deletar um usuário (cascade deleta seus posts também)
session.delete(usuario2)
session.commit()
print(f"Usuário {usuario2.nome} e seus posts foram deletados!")


print("\n=== 6. CONSULTAS MAIS AVANÇADAS ===")
from sqlalchemy import func

# Contagem de posts
total_posts = session.query(func.count(Post.id)).scalar()
print(f"Total de posts restantes: {total_posts}")

# Usuários com seus posts (join automático)
resultados = session.query(Usuario, Post).join(Post).all()
for usuario, post in resultados:
    print(f"{usuario.nome} escreveu: '{post.titulo}'")

# Filtro com LIKE
posts_com_python = session.query(Post).filter(Post.conteudo.like("%Python%")).all()
print(f"Posts mencionando Python: {posts_com_python}")


print("\n=== 7. FECHANDO CONEXÃO ===")
session.close()
print("Sessão fechada com sucesso!")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

# Instalação: pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, DateTime

from sqlalchemy.orm import declarative_base, sessionmaker, relationship

from datetime import datetime

# ============================================

# MODELOS (DEFINIÇÃO DAS TABELAS)

# ============================================

Base = declarative_base()

class Usuario(Base):

__tablename__ = 'usuarios'

id = Column(Integer, primary_key=True)

nome = Column(String(100), nullable=False)

email = Column(String(100), unique=True, nullable=False)

data_cadastro = Column(DateTime, default=datetime.now)

# Relacionamento: um usuário tem muitos posts

posts = relationship("Post", back_populates="autor", cascade="all, delete-orphan")

def __repr__(self):

return f"<Usuario(id={self.id}, nome='{self.nome}', email='{self.email}')>"

class Post(Base):

__tablename__ = 'posts'

id = Column(Integer, primary_key=True)

titulo = Column(String(200), nullable=False)

conteudo = Column(String, nullable=False)

data_publicacao = Column(DateTime, default=datetime.now)

usuario_id = Column(Integer, ForeignKey('usuarios.id'))

# Relacionamento: o post pertence a um usuário

autor = relationship("Usuario", back_populates="posts")

def __repr__(self):

return f"<Post(id={self.id}, titulo='{self.titulo}', autor_id={self.usuario_id})>"

# ============================================

# CONFIGURAÇÃO DO BANCO

# ============================================

# Conectando ao SQLite (em memória para exemplo)

engine = create_engine('sqlite:///:memory:', echo=True)

# Para arquivo real: 'sqlite:///meubanco.db'

# Para PostgreSQL: 'postgresql://user:pass@localhost/db'

# Cria todas as tabelas definidas

Base.metadata.create_all(engine)

# Cria uma fábrica de sessões

Session = sessionmaker(bind=engine)

session = Session()

# ============================================

# OPERAÇÕES CRUD (CREATE, READ, UPDATE, DELETE)

# ============================================

print("=== 1. CRIANDO USUÁRIOS ===")

usuario1 = Usuario(nome="Ana Silva", email="ana@email.com")

usuario2 = Usuario(nome="Carlos Oliveira", email="carlos@email.com")

usuario3 = Usuario(nome="Beatriz Santos", email="beatriz@email.com")

# Adicionando à sessão

session.add_all([usuario1, usuario2, usuario3])

session.commit() # Salva no banco

print(f"Usuários criados: {usuario1}, {usuario2}, {usuario3}")

print("\n=== 2. CRIANDO POSTS ===")

post1 = Post(titulo="Primeiro post", conteudo="Conteúdo do primeiro post", autor=usuario1)

post2 = Post(titulo="SQLAlchemy é incrível", conteudo="Aprendendo ORM em Python", autor=usuario1)

post3 = Post(titulo="Dicas de Python", conteudo="List comprehensions são úteis", autor=usuario2)

session.add_all([post1, post2, post3])

session.commit()

print(f"Posts criados: {post1}, {post2}, {post3}")

print("\n=== 3. CONSULTANDO DADOS ===")

# Buscar todos os usuários

todos_usuarios = session.query(Usuario).all()

print(f"Todos usuários: {todos_usuarios}")

# Filtrar por condição

usuario_ana = session.query(Usuario).filter(Usuario.nome == "Ana Silva").first()

print(f"Usuário encontrado pelo nome: {usuario_ana}")

# Filtrar por email (campo único)

usuario_carlos = session.query(Usuario).filter_by(email="carlos@email.com").first()

print(f"Usuário encontrado por email: {usuario_carlos}")

# Consultar posts de um usuário específico

posts_ana = usuario_ana.posts

print(f"Posts de Ana: {posts_ana}")

print("\n=== 4. ATUALIZANDO DADOS ===")

# Atualizar um usuário

usuario_carlos.nome = "Carlos Alberto Oliveira"

session.commit()

print(f"Usuário atualizado: {usuario_carlos}")

# Atualizar um post

post2.titulo = "SQLAlchemy ORM - Guia Completo"

session.commit()

print(f"Post atualizado: {post2}")

print("\n=== 5. DELETANDO DADOS ===")

# Deletar um post

session.delete(post3)

session.commit()

print(f"Post {post3.id} deletado!")

# Deletar um usuário (cascade deleta seus posts também)

session.delete(usuario2)

session.commit()

print(f"Usuário {usuario2.nome} e seus posts foram deletados!")

print("\n=== 6. CONSULTAS MAIS AVANÇADAS ===")

from sqlalchemy import func

# Contagem de posts

total_posts = session.query(func.count(Post.id)).scalar()

print(f"Total de posts restantes: {total_posts}")

# Usuários com seus posts (join automático)

resultados = session.query(Usuario, Post).join(Post).all()

for usuario, post in resultados:

print(f"{usuario.nome} escreveu: '{post.titulo}'")

# Filtro com LIKE

posts_com_python = session.query(Post).filter(Post.conteudo.like("%Python%")).all()

print(f"Posts mencionando Python: {posts_com_python}")

print("\n=== 7. FECHANDO CONEXÃO ===")

session.close()

print("Sessão fechada com sucesso!")

No exemplo, todas as operações são naturais. Criamos objetos Usuario e Post como classes normais. A sessão (session) gerencia as transações. Quando chamamos commit(), os dados vão ao banco. Consultas usam query() com filtros Python. Relacionamentos são acessados como atributos comuns. Por exemplo, usuario.posts retorna a lista de posts. Isso é muito mais legível que SQL puro. Além disso, o SQLAlchemy gerencia as chaves estrangeiras. Não precisamos escrever JOINs manualmente. Portanto, o código fica focado na lógica de negócio. Assim, você desenvolve aplicações mais rapidamente.

Outra vantagem importante é a portabilidade. Mude a string de conexão para outro banco. Por exemplo, troque sqlite:// por postgresql://. O código permanece exatamente igual. Isso é incrível para projetos que podem crescer. Primeiramente, comece com SQLite durante o desenvolvimento. Depois, migre para PostgreSQL em produção. Assim, você economiza tempo de configuração. Finalmente, sempre use sessões em contextos controlados. Evite manter sessões abertas por muito tempo. Use padrões como with session.begin(): para transações. Portanto, SQLAlchemy é uma ferramenta madura e confiável.

✅ Vantagens do SQLAlchemy
Abstração do banco de dados
Segurança contra SQL injection
Relacionamentos fáceis
Migrations com Alembic

⚠️ Desvantagens
Curva de aprendizado
Overhead em queries simples
Debugging mais complexo
Pode gerar SQL ineficiente

Para projetos pequenos, considere alternativas mais leves. Peewee ou SQLite puro podem ser suficientes. No entanto, para qualquer projeto profissional, SQLAlchemy brilha. Ele é usado por empresas como Reddit, Dropbox e SurveyMonkey. Isso atesta sua robustez e escalabilidade. Portanto, invista tempo aprendendo essa ferramenta. Ela será útil em praticamente todos seus projetos futuros. Primeiramente, domine os exemplos básicos apresentados. Depois, explore recursos avançados como eventos e híbridos. Assim, você se torna um desenvolvedor completo e eficiente.

Programação Declarativa: Foco no Resultado, Não nos Passos

25/04/202623/04/2026 Por antonino

– Python
– Declarativa
1 – SQLAlchemy (ORM)
2 – Django Models
3 – List/dict comprehensions
4 – Regex (expressões regulares)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

A programação declarativa descreve o que se deseja. Ela não especifica como alcançar o resultado. Isso contrasta com o estilo imperativo tradicional. Primeiramente, pense em SQL ou HTML como exemplos. Você diz “selecione clientes ativos”, não como buscar. Outro exemplo é o CSS para estilização de páginas. O foco está na lógica, não no fluxo de controle. Por essa razão, o código tende a ser mais legível. Além disso, muitos bugs de estado são evitados. Portanto, programação declarativa eleva o nível de abstração. Ela é usada em bancos de dados e interfaces reativas. Assim, você expressa intenção, não instruções passo a passo.

Características fundamentais do paradigma declarativo

Uma característica central é a imutabilidade implícita. Os dados não são alterados passo a passo. Em vez disso, novas estruturas são criadas. Outra propriedade importante é a ausência de loops explícitos. Operações são expressas como transformações de conjuntos. Por exemplo, map e filter são funções declarativas. Elas descrevem o que fazer, não como iterar. Isso foi popularizado por linguagens como SQL e Prolog. Mais recentemente, React e Vue adotaram essa filosofia. A separação entre “o quê” e “como” é clara. Consequentemente, o código se torna mais previsível. Testes também se beneficiam dessa abordagem.

Uma fórmula que resume a diferença é:

\(\text{Declarativo} = \text{O quê} \quad \text{Imperativo} = \text{Como}\)

Isso significa que declarativo foca no resultado final. Imperativo se preocupa com cada etapa do processo. Primeiramente, avalie se o problema é de transformação de dados. Se for, declarativo é geralmente superior. Para algoritmos complexos, imperativo ainda é necessário. Portanto, a escolha depende do domínio do problema.

Quando utilizar programação declarativa no seu código

Use declarações para consultas a bancos de dados. SQL é o exemplo mais bem-sucedido desse paradigma. Também use para definições de interface de usuário. Frameworks como React e Vue brilham nisso. Transformações de listas em Python são outro caso. Por exemplo, sorted() e sum() são declarativos. Eles escondem os detalhes de ordenação e soma. Outro bom uso é para regras de validação de dados. Você descreve as condições, não a checagem passo a passo. Por outro lado, evite declarativo para algoritmos de performance crítica. Nesses casos, o controle fino do imperativo é necessário. Além disso, problemas com muitos efeitos colaterais são complicados.

Primeiramente, identifique se seu código tem muitos loops. Se você escreve for i in range(len(lista)) com frequência, Isso é um sinal de que declarativo pode ajudar. Troque para map, filter ou list comprehensions. O resultado será mais legível e menos propenso a erros. Assim, você eleva a qualidade do seu código. Portanto, pratique a transição para o estilo declarativo.

Exemplo prático: convertendo imperativo para declarativo

O código abaixo mostra uma transformação real. Criamos uma lista de números e aplicamos filtros. A versão imperativa usa loops e condições manuais. A versão declarativa usa filter e map. Ambos produzem o mesmo resultado final. No entanto, o código declarativo é mais curto e claro. Observe como não há variáveis temporárias. Também não há necessidade de gerenciar índices. Isso reduz drasticamente a complexidade ciclomática. Vamos aos exemplos práticos para comparação.

# ============================================
# EXEMPLO 1: ESTILO IMPERATIVO (COMO FAZER)
# ============================================
print("=== Estilo Imperativo ===")

numeros = [10, 25, 3, 48, 17, 9, 30, 5, 42, 8]

# Obter números pares maiores que 10 e depois dobrá-los
resultado_imperativo = []
for num in numeros:
    if num % 2 == 0:  # É par?
        if num > 10:   # É maior que 10?
            resultado_imperativo.append(num * 2)

print(f"Original: {numeros}")
print(f"Resultado imperativo: {resultado_imperativo}")

# Calcular soma dos quadrados dos números ímpares
soma_quadrados_imperativo = 0
for num in numeros:
    if num % 2 != 0:  # É ímpar
        soma_quadrados_imperativo += num ** 2

print(f"Soma dos quadrados dos ímpares: {soma_quadrados_imperativo}")


# ============================================
# EXEMPLO 2: ESTILO DECLARATIVO (O QUE QUEREMOS)
# ============================================
print("\n=== Estilo Declarativo ===")

# Mesma operação com filter e map
resultado_declarativo = list(
    map(lambda x: x * 2,
        filter(lambda x: x % 2 == 0 and x > 10, numeros))
)
print(f"Resultado declarativo: {resultado_declarativo}")

# Usando list comprehension (ainda mais declarativo)
resultado_comprehension = [x * 2 for x in numeros if x % 2 == 0 and x > 10]
print(f"Com list comprehension: {resultado_comprehension}")

# Soma dos quadrados de ímpares com sum e generator
soma_quadrados_declarativo = sum(x ** 2 for x in numeros if x % 2 != 0)
print(f"Soma dos quadrados (declarativo): {soma_quadrados_declarativo}")


# ============================================
# EXEMPLO 3: TRANSFORMAÇÃO DE DADOS AVANÇADA
# ============================================
print("\n=== Transformação Avançada ===")

pessoas = [
    {"nome": "Ana", "idade": 32, "cidade": "São Paulo"},
    {"nome": "Carlos", "idade": 28, "cidade": "Rio de Janeiro"},
    {"nome": "Beatriz", "idade": 35, "cidade": "São Paulo"},
    {"nome": "Daniel", "idade": 22, "cidade": "Belo Horizonte"},
    {"nome": "Eduarda", "idade": 40, "cidade": "São Paulo"},
]

# Imperativo: filtrar pessoas de SP com mais de 30 anos
sp_imperativo = []
for pessoa in pessoas:
    if pessoa["cidade"] == "São Paulo" and pessoa["idade"] > 30:
        sp_imperativo.append(pessoa["nome"])

print(f"SP +30 (imperativo): {sp_imperativo}")

# Declarativo: mesmo resultado em uma linha
sp_declarativo = [
    p["nome"] for p in pessoas 
    if p["cidade"] == "São Paulo" and p["idade"] > 30
]
print(f"SP +30 (declarativo): {sp_declarativo}")

# Calcular média de idade (declarativo)
media_idade = sum(p["idade"] for p in pessoas) / len(pessoas)
print(f"Média de idade: {media_idade:.1f} anos")


# ============================================
# EXEMPLO 4: COMPARAÇÃO DE LEGIBILIDADE
# ============================================
print("\n=== Comparação de Legibilidade ===")

# Problema: encontrar o produto dos 3 maiores números
valores = [5, 2, 8, 1, 9, 3, 7, 4, 6]

# Imperativo
valores_ordenados = sorted(valores, reverse=True)
produto_imperativo = valores_ordenados[0] * valores_ordenados[1] * valores_ordenados[2]

# Declarativo (encadeamento)
from functools import reduce
produto_declarativo = reduce(
    lambda x, y: x * y,
    sorted(valores, reverse=True)[:3]
)

print(f"Produto dos 3 maiores ({valores}):")
print(f"  Imperativo: {produto_imperativo}")
print(f"  Declarativo: {produto_declarativo}")

100

101

102

# ============================================

# EXEMPLO 1: ESTILO IMPERATIVO (COMO FAZER)

# ============================================

print("=== Estilo Imperativo ===")

numeros = [10, 25, 3, 48, 17, 9, 30, 5, 42, 8]

# Obter números pares maiores que 10 e depois dobrá-los

resultado_imperativo = []

for num in numeros:

if num % 2 == 0: # É par?

if num > 10: # É maior que 10?

resultado_imperativo.append(num * 2)

print(f"Original: {numeros}")

print(f"Resultado imperativo: {resultado_imperativo}")

# Calcular soma dos quadrados dos números ímpares

soma_quadrados_imperativo = 0

for num in numeros:

if num % 2 != 0: # É ímpar

soma_quadrados_imperativo += num ** 2

print(f"Soma dos quadrados dos ímpares: {soma_quadrados_imperativo}")

# ============================================

# EXEMPLO 2: ESTILO DECLARATIVO (O QUE QUEREMOS)

# ============================================

print("\n=== Estilo Declarativo ===")

# Mesma operação com filter e map

resultado_declarativo = list(

map(lambda x: x * 2,

filter(lambda x: x % 2 == 0 and x > 10, numeros))

)

print(f"Resultado declarativo: {resultado_declarativo}")

# Usando list comprehension (ainda mais declarativo)

resultado_comprehension = [x * 2 for x in numeros if x % 2 == 0 and x > 10]

print(f"Com list comprehension: {resultado_comprehension}")

# Soma dos quadrados de ímpares com sum e generator

soma_quadrados_declarativo = sum(x ** 2 for x in numeros if x % 2 != 0)

print(f"Soma dos quadrados (declarativo): {soma_quadrados_declarativo}")

# ============================================

# EXEMPLO 3: TRANSFORMAÇÃO DE DADOS AVANÇADA

# ============================================

print("\n=== Transformação Avançada ===")

pessoas = [

{"nome": "Ana", "idade": 32, "cidade": "São Paulo"},

{"nome": "Carlos", "idade": 28, "cidade": "Rio de Janeiro"},

{"nome": "Beatriz", "idade": 35, "cidade": "São Paulo"},

{"nome": "Daniel", "idade": 22, "cidade": "Belo Horizonte"},

{"nome": "Eduarda", "idade": 40, "cidade": "São Paulo"},

]

# Imperativo: filtrar pessoas de SP com mais de 30 anos

sp_imperativo = []

for pessoa in pessoas:

if pessoa["cidade"] == "São Paulo" and pessoa["idade"] > 30:

sp_imperativo.append(pessoa["nome"])

print(f"SP +30 (imperativo): {sp_imperativo}")

# Declarativo: mesmo resultado em uma linha

sp_declarativo = [

p["nome"] for p in pessoas

if p["cidade"] == "São Paulo" and p["idade"] > 30

]

print(f"SP +30 (declarativo): {sp_declarativo}")

# Calcular média de idade (declarativo)

media_idade = sum(p["idade"] for p in pessoas) / len(pessoas)

print(f"Média de idade: {media_idade:.1f} anos")

# ============================================

# EXEMPLO 4: COMPARAÇÃO DE LEGIBILIDADE

# ============================================

print("\n=== Comparação de Legibilidade ===")

# Problema: encontrar o produto dos 3 maiores números

valores = [5, 2, 8, 1, 9, 3, 7, 4, 6]

# Imperativo

valores_ordenados = sorted(valores, reverse=True)

produto_imperativo = valores_ordenados[0] * valores_ordenados[1] * valores_ordenados[2]

# Declarativo (encadeamento)

from functools import reduce

produto_declarativo = reduce(

lambda x, y: x * y,

sorted(valores, reverse=True)[:3]

)

print(f"Produto dos 3 maiores ({valores}):")

print(f" Imperativo: {produto_imperativo}")

print(f" Declarativo: {produto_declarativo}")

Compare as versões lado a lado com atenção. O código imperativo usa variáveis de estado temporárias. Isso aumenta a carga cognitiva do programador. O código declarativo expressa diretamente a intenção. Não há append ou índices para gerenciar. Além disso, a versão declarativa é mais concisa. Ela também é menos propensa a erros de off-by-one. Primeiramente, pratique converter seus loops em comprehensions. Depois, evolua para map e filter combinados. A lista comprehension é geralmente a mais legível. Portanto, use-a como padrão para transformações simples. Assim, seu código se torna mais profissional.

Outra vantagem importante é a testabilidade. Funções puras são declarativas por natureza. Elas não dependem de estado externo ou tempo. Isso facilita testes unitários isolados. Por exemplo, sorted(lista) sempre retorna o mesmo. Já um loop que modifica uma variável global não. Portanto, busque funções declarativas e puras. Elas são mais fáceis de entender e depurar. Além disso, a performance costuma ser equivalente. Em alguns casos, até melhor devido a otimizações. Assim, você ganha legibilidade sem perder eficiência.

Imperativo
✅ Controle fino
✅ Fácil para iniciantes
❌ Mais verboso
❌ Estado explícito

Declarativo
✅ Mais legível
✅ Menos bugs de estado
❌ Curva de aprendizado
❌ Menos controle

Finalmente, lembre-se que a divisão não é binária. Muitas linguagens permitem misturar ambos estilos. Python é uma delas: use o melhor para cada caso. Em geral, prefira declarativo para transformações de dados. Use imperativo para algoritmos complexos ou I/O sequencial. Primeiramente, comece pequeno: uma comprehension por vez. Depois, reescreva funções inteiras no novo estilo. Com a prática, a escolha se torna natural. A evolução do seu código será evidente. Portanto, invista tempo em aprender esse paradigma. Ele é amplamente valorizado no mercado atual. Assim, você se torna um programador mais completo.