antonino, Autor em Área de Trampo

Lógica Declarativa em Python

25/04/202623/04/2026 Por antonino

– Python
– Logica (limitada)
1 – pyDatalog
2 – SymPy (lógica simbólica)
3 – Simulação com regras (ex: regras de negócio)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Python vai além da lógica booleana tradicional. Bibliotecas como pyDatalog e SymPy expandem esse horizonte. Primeiramente, pyDatalog implementa programação lógica. Ela é inspirada em Prolog para Python puro. SymPy é uma biblioteca de matemática simbólica. Ambas permitem simular sistemas baseados em regras. Por exemplo, regras de negócio podem ser formalizadas. Isso é útil para sistemas especialistas e inferência. Além disso, a simulação com regras é declarativa. Você descreve o que o sistema deve fazer, não como. Portanto, essas ferramentas elevam o nível de abstração. Assim, problemas complexos se tornam mais tratáveis.

pyDatalog: programação lógica em Python

pyDatalog adiciona fatos e regras a programas Python. Um fato é uma afirmação verdadeira sobre o mundo. Por exemplo, “pai(jose, ana)” significa que José é pai de Ana. Uma regra define relacionamentos condicionais. Por exemplo, “avô(X, Z) :- pai(X, Y), pai(Y, Z)”. Isso significa: X é avô de Z se X é pai de Y e Y é pai de Z. Primeiramente, instale com pip install pyDatalog. As consultas retornam todas as soluções possíveis. Isso foi inspirado em bancos de dados dedutivos. Consequentemente, você faz perguntas complexas declarativamente. Use pyDatalog para sistemas de recomendação. Também para validação de regras de negócio. Portanto, é uma ferramenta poderosa para lógica simbólica.

Uma fórmula que representa uma regra pyDatalog é:

$\text{Conclusão} \leftarrow \text{Condição}_1 \land \text{Condição}_2 \land \dots$

Isso significa que a conclusão é verdadeira se todas as condições forem verdadeiras. Além disso, pyDatalog suporta agregações e aritmética. No entanto, a performance pode cair para fatos muito grandes. Use para conjuntos de dados pequenos ou médios. Portanto, avalie o tamanho do seu domínio antes.

SymPy: matemática simbólica e lógica formal

SymPy manipula expressões matemáticas simbolicamente. Ela resolve equações, simplifica termos e calcula derivadas. Além disso, SymPy possui módulo de lógica proposicional. Você pode criar símbolos lógicos e avaliar expressões. Por exemplo, And(x, Or(y, z)) representa uma fórmula. Use satisfiable() para encontrar valores que a tornam verdadeira. Isso foi projetado para verificação de tautologias. Primeiramente, instale com pip install sympy. SymPy também resolve quantificadores lógicos. Por exemplo, “existe um x tal que P(x) é verdadeiro”. Use para sistemas de verificação formal. Também para provadores de teoremas educacionais. Portanto, SymPy é uma ferramenta acadêmica robusta.

Outra aplicação é a simulação com restrições. Defina regras de negócio como equações matemáticas. SymPy resolve sistemas de inequações automaticamente. Isso foi usado em planejamento financeiro e logística. Por exemplo, “orçamento < custo_total + margem”. A biblioteca encontra os valores que satisfazem as restrições. Assim, você automatiza decisões complexas. Portanto, SymPy vai além da matemática pura.

Quando usar cada ferramenta na simulação de regras

Use pyDatalog para relações hierárquicas e recursivas. Árvores genealógicas, grafos e sistemas de permissões são ideais. Também use para motores de inferência simples. Por outro lado, use SymPy para restrições numéricas. Regras de preços, descontos e impostos se encaixam. Além disso, use SymPy quando precisar de provas formais. Para sistemas mistos, combine ambas as bibliotecas. Primeiramente, modele as regras em linguagem natural. Depois, traduza para fatos pyDatalog ou equações SymPy. Isso facilita a validação com stakeholders de negócio. Evite pyDatalog para cálculos numéricos intensivos. SymPy não é otimizada para milhões de fatos. Portanto, escolha a ferramenta adequada ao seu problema.

Outro bom uso é para simulação de cenários de negócio. Por exemplo, regras de aprovação de crédito. “Cliente aprovado se renda > 2000 e sem restrições”. Você implementa como regras declarativas. Depois, testa diferentes combinações de entradas. Isso foi adotado em fintechs e seguradoras. Portanto, essas ferramentas são práticas e relevantes.

Exemplo prático: sistema de regras com pyDatalog e SymPy

O código abaixo demonstra ambas as bibliotecas. Primeiro, um sistema de parentesco com pyDatalog. Definimos fatos sobre uma família típica. Regras definem avô, irmão e tio. Depois, consultamos relações interessantes. Em seguida, usamos SymPy para lógica proposicional. Criamos símbolos para variáveis lógicas. Avaliamos expressões e verificamos consistência. Por fim, um sistema de restrições financeiras. Resolvemos inequações para encontrar valores permitidos. Observe como a lógica declarativa simplifica a tarefa. Vamos ao código comentado para detalhes.

# Instalação: pip install pyDatalog sympy

# ============================================
# PARTE 1: PYDATALOG - RELAÇÕES FAMILIARES
# ============================================
print("=== pyDatalog: Genealogia ===")

from pyDatalog import pyDatalog

# Criar termos
pyDatalog.create_terms('pai, mae, avo, irmao, tio, X, Y, Z')

# Fatos (base de conhecimento)
+pai('joao', 'maria')
+pai('joao', 'jose')
+pai('carlos', 'ana')
+pai('jose', 'lucas')
+mae('maria', 'ana')
+mae('maria', 'paulo')
+mae('ana', 'sofia')

# Regra: avô
avo(X, Z) <= pai(X, Y) & pai(Y, Z)

# Regra: irmão (mesmo pai)
irmao(X, Y) <= pai(Z, X) & pai(Z, Y) & (X != Y)

# Regra: tio (irmão dos pais)
tio(X, Y) <= irmao(X, Z) & pai(Z, Y)

# Consultas
print("Avôs de ana:")
print(avo(X, 'ana'))

print("\nIrmãos de ana:")
print(irmao(X, 'ana'))

print("\nTios de sofia:")
print(tio(X, 'sofia'))

# Consulta com argumento variável
print("\nTodos os avôs e netos:")
print(avo(X, Y))


# ============================================
# PARTE 2: SYMPY - LÓGICA PROPOSICIONAL
# ============================================
print("\n=== SymPy: Lógica e Tabelas Verdade ===")

from sympy import symbols, And, Or, Not, Implies, satisfiable, simplify_logic
from sympy.logic.boolalg import truth_table

# Definir símbolos lógicos
a, b, c = symbols('a b c')

# Expressão: (a AND b) OR (NOT a AND c)
expr = Or(And(a, b), And(Not(a), c))
print(f"Expressão: {expr}")

# Simplificar
simplificada = simplify_logic(expr)
print(f"Simplificada: {simplificada}")

# Verificar se é satisfatória
print(f"Satisfatível? {satisfiable(expr)}")

# Encontrar uma solução (valores que tornam verdadeiro)
solucao = satisfiable(expr, all_models=False)
print(f"Uma solução: {solucao}")

# Leis de De Morgan demonstradas
dm = Not(And(a, b))
dm_equiv = Or(Not(a), Not(b))
print(f"\nDe Morgan: {dm} é equivalente a {dm_equiv}")
print(f"São equivalentes? {simplify_logic(dm) == simplify_logic(dm_equiv)}")

# Implicação lógica: A -> B é equivalente a NOT A OR B
implicacao = Implies(a, b)
equivalente = Or(Not(a), b)
print(f"Implicação {implicacao} = {equivalente}")


# ============================================
# PARTE 3: SYMPY - RESTRIÇÕES E REGRAS DE NEGÓCIO
# ============================================
print("\n=== SymPy: Restrições de Negócio ===")

from sympy.solvers import solve_univariate_inequality
from sympy import Symbol, Eq, Le, And

# Regra de aprovação de crédito
renda = Symbol('renda', real=True)
divida = Symbol('divida', real=True)
score = Symbol('score', real=True)

# Regra: renda > 2000, divida/renda < 0.3, score > 600
regra1 = renda > 2000
regra2 = (divida / renda) < 0.3
regra3 = score > 600
regra_aprovacao = And(regra1, regra2, regra3)

print(f"Regra de aprovação: {regra_aprovacao}")

# Testar um cenário específico
from sympy import solve

cenario = {renda: 5000, divida: 1000, score: 650}
avaliacao = {}
for cond in regra_aprovacao.args:
    resultado = cond.subs(cenario)
    avaliacao[str(cond)] = resultado
print(f"Avaliação do cenário: {avaliacao}")

# Resolver a faixa de renda permitida (dívida e score fixos)
divida_fixa = 1000
score_fixo = 700
regra_renda = (renda > 2000) & ((divida_fixa / renda) < 0.3)

# Simplificar a condição da renda
from sympy import reduce_inequalities
try:
    rendas_permitidas = reduce_inequalities(regra_renda, renda)
    print(f"Renda permitida: {rendas_permitidas}")
except:
    # Solução manual
    cond1 = renda > 2000
    cond2 = renda > (divida_fixa / 0.3)
    limiar = divida_fixa / 0.3
    print(f"Renda deve ser > 2000 e > {limiar:.2f}, ou seja > {max(2000, limiar):.2f}")


# ============================================
# PARTE 4: SIMULAÇÃO COM REGRAS MISTAS
# ============================================
print("\n=== Simulação de Regras de Negócio ===")

# Simular diferentes combinações de renda e dívida
cenarios = [
    {"renda": 1800, "divida": 500, "score": 700, "nome": "Renda baixa"},
    {"renda": 3000, "divida": 1200, "score": 580, "nome": "Score baixo"},
    {"renda": 3000, "divida": 1200, "score": 650, "nome": "Dívida alta"},
    {"renda": 5000, "divida": 800, "score": 720, "nome": "Aprovado ideal"},
    {"renda": 2500, "divida": 400, "score": 710, "nome": "Aprovado limite"},
]

def avaliar_cliente(renda_val, divida_val, score_val):
    """Avalia cliente baseado nas regras."""
    regras = [
        ("Renda adequada", renda_val > 2000),
        ("Dívida controlada", (divida_val / renda_val) < 0.3),
        ("Score suficiente", score_val > 600),
    ]
    resultados = []
    for nome, ok in regras:
        resultados.append(f"{nome}: {'✅' if ok else '❌'}")
    aprovado = all(ok for _, ok in regras)
    return aprovado, resultados

print("\nAnálise de cenários:")
for cenario in cenarios:
    aprovado, detalhes = avaliar_cliente(cenario["renda"], cenario["divida"], cenario["score"])
    print(f"\n{cenario['nome']} (R${cenario['renda']}, Dívida: R${cenario['divida']}, Score: {cenario['score']})")
    print(f"  Aprovado: {'✅ SIM' if aprovado else '❌ NÃO'}")
    for det in detalhes:
        print(f"  {det}")

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

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

# Instalação: pip install pyDatalog sympy

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

# PARTE 1: PYDATALOG - RELAÇÕES FAMILIARES

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

print("=== pyDatalog: Genealogia ===")

from pyDatalog import pyDatalog

# Criar termos

pyDatalog.create_terms('pai, mae, avo, irmao, tio, X, Y, Z')

# Fatos (base de conhecimento)

+pai('joao', 'maria')

+pai('joao', 'jose')

+pai('carlos', 'ana')

+pai('jose', 'lucas')

+mae('maria', 'ana')

+mae('maria', 'paulo')

+mae('ana', 'sofia')

# Regra: avô

avo(X, Z) <= pai(X, Y) & pai(Y, Z)

# Regra: irmão (mesmo pai)

irmao(X, Y) <= pai(Z, X) & pai(Z, Y) & (X != Y)

# Regra: tio (irmão dos pais)

tio(X, Y) <= irmao(X, Z) & pai(Z, Y)

# Consultas

print("Avôs de ana:")

print(avo(X, 'ana'))

print("\nIrmãos de ana:")

print(irmao(X, 'ana'))

print("\nTios de sofia:")

print(tio(X, 'sofia'))

# Consulta com argumento variável

print("\nTodos os avôs e netos:")

print(avo(X, Y))

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

# PARTE 2: SYMPY - LÓGICA PROPOSICIONAL

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

print("\n=== SymPy: Lógica e Tabelas Verdade ===")

from sympy import symbols, And, Or, Not, Implies, satisfiable, simplify_logic

from sympy.logic.boolalg import truth_table

# Definir símbolos lógicos

a, b, c = symbols('a b c')

# Expressão: (a AND b) OR (NOT a AND c)

expr = Or(And(a, b), And(Not(a), c))

print(f"Expressão: {expr}")

# Simplificar

simplificada = simplify_logic(expr)

print(f"Simplificada: {simplificada}")

# Verificar se é satisfatória

print(f"Satisfatível? {satisfiable(expr)}")

# Encontrar uma solução (valores que tornam verdadeiro)

solucao = satisfiable(expr, all_models=False)

print(f"Uma solução: {solucao}")

# Leis de De Morgan demonstradas

dm = Not(And(a, b))

dm_equiv = Or(Not(a), Not(b))

print(f"\nDe Morgan: {dm} é equivalente a {dm_equiv}")

print(f"São equivalentes? {simplify_logic(dm) == simplify_logic(dm_equiv)}")

# Implicação lógica: A -> B é equivalente a NOT A OR B

implicacao = Implies(a, b)

equivalente = Or(Not(a), b)

print(f"Implicação {implicacao} = {equivalente}")

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

# PARTE 3: SYMPY - RESTRIÇÕES E REGRAS DE NEGÓCIO

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

print("\n=== SymPy: Restrições de Negócio ===")

from sympy.solvers import solve_univariate_inequality

from sympy import Symbol, Eq, Le, And

# Regra de aprovação de crédito

renda = Symbol('renda', real=True)

divida = Symbol('divida', real=True)

score = Symbol('score', real=True)

# Regra: renda > 2000, divida/renda < 0.3, score > 600

regra1 = renda > 2000

regra2 = (divida / renda) < 0.3

regra3 = score > 600

regra_aprovacao = And(regra1, regra2, regra3)

print(f"Regra de aprovação: {regra_aprovacao}")

# Testar um cenário específico

from sympy import solve

cenario = {renda: 5000, divida: 1000, score: 650}

avaliacao = {}

for cond in regra_aprovacao.args:

resultado = cond.subs(cenario)

avaliacao[str(cond)] = resultado

print(f"Avaliação do cenário: {avaliacao}")

# Resolver a faixa de renda permitida (dívida e score fixos)

divida_fixa = 1000

score_fixo = 700

regra_renda = (renda > 2000) & ((divida_fixa / renda) < 0.3)

# Simplificar a condição da renda

from sympy import reduce_inequalities

try:

rendas_permitidas = reduce_inequalities(regra_renda, renda)

print(f"Renda permitida: {rendas_permitidas}")

except:

# Solução manual

cond1 = renda > 2000

cond2 = renda > (divida_fixa / 0.3)

limiar = divida_fixa / 0.3

print(f"Renda deve ser > 2000 e > {limiar:.2f}, ou seja > {max(2000, limiar):.2f}")

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

# PARTE 4: SIMULAÇÃO COM REGRAS MISTAS

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

print("\n=== Simulação de Regras de Negócio ===")

# Simular diferentes combinações de renda e dívida

cenarios = [

{"renda": 1800, "divida": 500, "score": 700, "nome": "Renda baixa"},

{"renda": 3000, "divida": 1200, "score": 580, "nome": "Score baixo"},

{"renda": 3000, "divida": 1200, "score": 650, "nome": "Dívida alta"},

{"renda": 5000, "divida": 800, "score": 720, "nome": "Aprovado ideal"},

{"renda": 2500, "divida": 400, "score": 710, "nome": "Aprovado limite"},

]

def avaliar_cliente(renda_val, divida_val, score_val):

"""Avalia cliente baseado nas regras."""

regras = [

("Renda adequada", renda_val > 2000),

("Dívida controlada", (divida_val / renda_val) < 0.3),

("Score suficiente", score_val > 600),

]

resultados = []

for nome, ok in regras:

resultados.append(f"{nome}: {'✅' if ok else '❌'}")

aprovado = all(ok for _, ok in regras)

return aprovado, resultados

print("\nAnálise de cenários:")

for cenario in cenarios:

aprovado, detalhes = avaliar_cliente(cenario["renda"], cenario["divida"], cenario["score"])

print(f"\n{cenario['nome']} (R${cenario['renda']}, Dívida: R${cenario['divida']}, Score: {cenario['score']})")

print(f" Aprovado: {'✅ SIM' if aprovado else '❌ NÃO'}")

for det in detalhes:

print(f" {det}")

Nos exemplos, a abordagem declarativa é evidenciada. pyDatalog resolve relações recursivas com facilidade. Apenas declaramos fatos e regras. O motor de inferência encontra as respostas automaticamente. SymPy, por outro lado, manipula símbolos matematicamente. As regras de negócio são expressas como inequações. O sistema encontra os valores que as satisfazem. Primeiramente, modele seu domínio como fatos ou equações. Depois, deixe a biblioteca fazer as deduções. Isso reduz drasticamente a complexidade do código imperativo. Além disso, a manutenção das regras se torna mais simples. Portanto, para problemas com muitas regras, vale o esforço.

Outro ponto importante é a documentação das regras. Regras declarativas são quase linguagem natural. Stakeholders de negócio podem validá-las diretamente. Isso foi um diferencial em projetos de sucesso. Para sistemas maiores, combine pyDatalog com bancos de dados. SymPy integra-se bem com pandas para análise numérica. Porém, o desempenho tem seus limites inevitáveis. Para milhões de fatos ou equações, considere outras soluções. Nesses casos, use bancos de dados gráficos ou solvers dedicados. Primeiramente, prototipe com Python para validar a lógica. Depois, escale para soluções mais robustas se necessário. Assim, você ganha agilidade sem comprometer qualidade.

📌 Resumo das ferramentas:
✅ pyDatalog: relações lógicas, árvores, sistemas especialistas
✅ SymPy: matemática simbólica, restrições, lógica formal
✅ Combinação: regras mistas (relações + matemática)

Finalmente, experimente criar seu próprio sistema de regras. Comece com um domínio pequeno, como aprovação de empréstimos. Ou implemente um sistema de recomendação de filmes. Use pyDatalog para relações de gêneros e atores. Use SymPy para calcular notas e preferências. A combinação delas é extremamente poderosa. Portanto, essas bibliotecas merecem seu estudo. Instale e brinque com os exemplos fornecidos. Você descobrirá novas formas de resolver problemas. Assim, seu repertório técnico se expande significativamente.

Expressões Regulares (Regex): Padrões para Buscar Texto

22/05/202623/04/2026 Por antonino

Expressões regulares são padrões usados para buscar texto. Elas permitem encontrar, extrair e substituir substrings. Primeiramente, dominar regex é uma habilidade valiosa. Com poucos símbolos, fazemos buscas complexas. Por exemplo, \d{3}-\d{3} encontra formatos como “123-456”. Sem regex, isso exigiria várias linhas de código. Além disso, regex funciona em muitas linguagens. Python, JavaScript, Java e PHP suportam o mesmo padrão. Portanto, o conhecimento é portável entre ecossistemas. No Python, usamos o módulo re nativo. Assim, você pode validar emails, CPFs, telefones e mais. Essa ferramenta foi projetada para eficiência e precisão.

Características fundamentais das expressões regulares

Uma regex é construída com metacaracteres especiais. O ponto (.) significa qualquer caractere (exceto quebra). O asterisco (*) repete o padrão zero ou mais vezes. O mais (+) repete uma ou mais vezes. A interrogação (?) torna algo opcional. Colchetes [abc] indicam “um destes caracteres”. Barras invertidas criam classes como \d (dígitos) ou \w (letras/números). Isso foi inspirado na teoria de linguagens formais. Uma fórmula que representa uma regex básica é:

$\text{Padrão} = [a-zA-Z0-9][\text{metacaracteres}]$

Primeiramente, comece com padrões simples. Depois, adicione complexidade gradualmente. Teste sempre com ferramentas online como regex101.com. Assim, você evita frustrações comuns no aprendizado.

Outra característica importante são os grupos e capturas. Parênteses () agrupam partes do padrão. Eles também capturam o texto correspondente. Você pode referenciar grupos por números ou nomes. Isso é útil para extrair partes específicas de um texto. Por exemplo, capturar dia, mês e ano de uma data. Consequentemente, você processa dados estruturados dentro de texto bruto.

Metacaracteres mais úteis e suas funções

Os metacaracteres são o coração das expressões regulares. O símbolo ^ ancora no início da string. O símbolo $ ancora no final da string. A barra vertical | funciona como OU lógico. Por exemplo, gato|cão encontra qualquer um deles. Colchetes com hífen criam intervalos: [a-z] são letras minúsculas. O metacaractere \b indica borda de palavra. Isso é útil para buscar palavras inteiras, não substrings. Além disso, \B é o oposto (não borda). Quantificadores como {n,m} controlam repetições exatas. Por exemplo, \d{2,4} encontra 2 a 4 dígitos. Portanto, dominar esses símbolos é fundamental.

Outro grupo importante são os atalhos pré-definidos. \D corresponde a qualquer não-dígito. \W corresponde a qualquer não-letra/número. \S corresponde a qualquer não-espaço. Eles são úteis para negar classes de caracteres. Por exemplo, \D+ captura tudo que não é número. Use esses atalhos para limpar dados rapidamente. Isso foi projetado para tornar regex mais legível. Primeiramente, decore os atalhos mais comuns. Depois, use tabelas de consulta para os raros. Assim, você escreve padrões mais expressivos.

Quando utilizar expressões regulares no dia a dia

Use regex para validação de formatos conhecidos. E-mails, URLs, placas de carro e CPF são exemplos. Também são ótimas para substituições complexas em massa. Por exemplo, trocar todos os números de telefone em um texto. Outro bom uso é para extração de dados em logs. Arquivos de servidor ou sistemas legacy são ideais. Além disso, regex ajuda na limpeza de dados textuais. Por outro lado, evite regex para HTML ou XML aninhados. Esses formatos não são regulares (contexto livre). Use parsers dedicados como BeautifulSoup nesses casos. Primeiramente, avalie se o padrão é linear. Se for, regex é sua melhor ferramenta. Portanto, regex é poderosa, mas não para tudo.

Outro bom uso é na busca dentro de editores de texto. VS Code, Sublime e Vim suportam regex nas buscas. Isso acelera drasticamente refatorações de código. Use também em pipelines de processamento de dados. Apache Spark e Pandas aceitam regex para filtros. Isso foi amplamente adotado na engenharia de dados. Portanto, regex é um curinga para muitos problemas.

Boas práticas e armadilhas comuns

Sempre use strings raw r"..." para evitar escapes duplicados. Isso torna a regex muito mais legível e segura. Outra boa prática é compilar padrões reutilizáveis com re.compile(). Isso melhora a performance em loops grandes. Além disso, comente regexes complexas com detalhes. Use o modo verbose (re.VERBOSE) para isso. Ele permite espaços e comentários dentro do padrão. Uma armadilha comum é o greedy vs non-greedy. Por padrão, quantificadores capturam o máximo possível. Use *? ou +? para captura mínima (lazy). Isso foi projetado para evitar capturar mais do que se deseja. Portanto, teste sempre com vários casos de borda.

Outra armadilha é esquecer de escapar caracteres literais. Ponto, colchetes, parênteses e asterisco precisam de \. Esqueça isso e sua regex terá comportamento inesperado. Além disso, evite regex excessivamente longas e aninhadas. Elas são difíceis de depurar e manter no futuro. Primeiramente, divida problemas complexos em etapas menores. Use variáveis para construir padrões aos poucos. Teste cada parte separadamente antes de combinar. Assim, você mantém a sanidade mental do programador. Portanto, documente e teste suas expressões regulares sempre.

Exemplo prático: validação e extração com re

O código abaixo demonstra os principais usos do módulo re. Primeiro, validamos formatos comuns como e-mail e telefone. Depois, extraímos partes específicas de um texto. Também mostramos substituições em massa expressivas. Usamos também flags para buscas case-insensitive. Por fim, otimizamos padrões com compilação prévia. Observe como poucas linhas resolvem problemas complexos. Sem regex, o mesmo código teria muitas condições. Vamos ao código comentado com vários exemplos práticos.

import re

# ============================================
# EXEMPLO 1: VALIDAÇÃO DE FORMATOS
# ============================================
print("=== Validação de Formatos ===")

# Validar e-mail simples (versão educacional)
email_padrao = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

emails_teste = [
    "usuario@email.com",
    "nome.sobrenome@empresa.com.br",
    "invalido@",
    "sem_arroba.com",
    "123@456.789"
]

for email in emails_teste:
    if re.match(email_padrao, email):
        print(f"✅ Válido: {email}")
    else:
        print(f"❌ Inválido: {email}")

# Validar telefone brasileiro (com ou sem DDD)
telefone_padrao = r'^(\(?\d{2}\)?\s?)?9?\d{4}-\d{4}$'

telefones = [
    "(11) 91234-5678",
    "11912345678",
    "91234-5678",
    "1234-5678",  # inválido (celular precisa do 9)
    "(11) 1234-5678"
]

print("\n=== Validação de Telefones ===")
for tel in telefones:
    if re.match(telefone_padrao, tel):
        print(f"✅ Válido: {tel}")
    else:
        print(f"❌ Inválido: {tel}")


# ============================================
# EXEMPLO 2: EXTRAÇÃO DE DADOS
# ============================================
print("\n=== Extração de Dados ===")

texto = """
Data: 2024-01-15, venda de R$ 1.234,56 para cliente Ana.
Em 2024-02-20, valor de R$ 2.500,00 para Carlos.
Total do mês: R$ 12.345,67
"""

# Extrair todas as datas no formato YYYY-MM-DD
datas = re.findall(r'\d{4}-\d{2}-\d{2}', texto)
print(f"Datas encontradas: {datas}")

# Extrair valores monetários (R$ 1.234,56)
valores = re.findall(r'R\$ [\d\.]+,\d{2}', texto)
print(f"Valores encontrados: {valores}")

# Extrair usando grupos (captura)
padrao_data_grupo = r'(\d{4})-(\d{2})-(\d{2})'
for data in re.finditer(padrao_data_grupo, texto):
    ano, mes, dia = data.groups()
    print(f"Data capturada -> Ano: {ano}, Mês: {mes}, Dia: {dia}")

# Nomear grupos (Python 3.8+)
padrao_nomeado = r'(?P\d{2})/(?P\d{2})/(?P\d{4})'
texto_data_br = "Ontem foi 15/03/2024 e hoje é 16/03/2024"
for match in re.finditer(padrao_nomeado, texto_data_br):
    print(f"Dia: {match.group('dia')}, Mês: {match.group('mes')}, Ano: {match.group('ano')}")


# ============================================
# EXEMPLO 3: SUBSTITUIÇÕES COM re.sub()
# ============================================
print("\n=== Substituições ===")

# Esconder e-mails
texto_emails = "Contato: ana@email.com ou carlos@empresa.com.br"
anonimizado = re.sub(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', 
                     '[EMAIL OCULTO]', texto_emails)
print(f"Original: {texto_emails}")
print(f"Anonimizado: {anonimizado}")

# Limpar números de uma string
texto_sujo = "Pedido #1234 - Valor R$ 567,89"
apenas_numeros = re.sub(r'[^0-9]', '', texto_sujo)
print(f"Apenas números: {apenas_numeros}")

# Converter datas BR para ISO (função com re.sub)
def converter_iso(match):
    dia, mes, ano = match.groups()
    return f"{ano}-{mes}-{dia}"

texto_datas = "15/03/2024 e 20/12/2023"
iso_datas = re.sub(r'(\d{2})/(\d{2})/(\d{4})', converter_iso, texto_datas)
print(f"Datas em ISO: {iso_datas}")


# ============================================
# EXEMPLO 4: FLAGS E COMPILAÇÃO
# ============================================
print("\n=== Flags e Compilação ===")

# Case-insensitive (IGNORECASE)
texto_exemplo = "Python é PYTHON poderoso. python também."
python_comp = re.findall(r'python', texto_exemplo, re.IGNORECASE)
print(f"Pythons encontrados: {python_comp}")

# Busca multilinha (MULTILINE)
codigo = """
def funcao():
    pass

class Teste:
    pass
"""

# Encontrar linhas que começam com def ou class
padrao_inicio = r'^(def|class)\s+\w+'
encontrados = re.findall(padrao_inicio, codigo, re.MULTILINE)
print(f"Definições encontradas: {encontrados}")

# Compilar padrão para reutilização
padrao_compilado = re.compile(r'\b\w{3,5}\b', re.IGNORECASE)
palavras = padrao_compilado.findall("Python regex é muito útil para buscas complexas")
print(f"Palavras com 3-5 letras: {palavras}")


# ============================================
# EXEMPLO 5: EXEMPLOS PRÁTICOS COMUNS
# ============================================
print("\n=== Exemplos Práticos ===")

# Extrair todas as URLs de um texto
texto_urls = "Visite https://python.org e http://example.com ou www.google.com"
url_padrao = r'https?://[a-zA-Z0-9./-]+|www\.[a-zA-Z0-9./-]+'
urls = re.findall(url_padrao, texto_urls)
print(f"URLs encontradas: {urls}")

# Validar CPF (formato apenas, sem dígito verificador)
cpf_padrao = r'^\d{3}\.\d{3}\.\d{3}-\d{2}$'
cpfs = ["123.456.789-00", "11122233344", "abc.def.ghi-jk"]
for cpf in cpfs:
    if re.match(cpf_padrao, cpf):
        print(f"✅ CPF válido: {cpf}")
    else:
        print(f"❌ CPF inválido: {cpf}")

# Separar palavra em sílabas simples (educacional)
palavra = "programacao"
silabas = re.findall(r'[bcdfghjklmnpqrstvwyxz]*[aeiouáéíóú]+', palavra)
print(f"Sílabas de '{palavra}': {silabas}")

# Limpar caracteres especiais
texto_sujo = "Olá, como você está? Hoje é 15/03!"
limpo = re.sub(r'[^\w\s]', '', texto_sujo, encoding='utf-8')
print(f"Texto limpo (apenas letras/ números/ espaços): {limpo}")

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

150

151

152

153

154

155

156

157

158

159

160

161

import re

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

# EXEMPLO 1: VALIDAÇÃO DE FORMATOS

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

print("=== Validação de Formatos ===")

# Validar e-mail simples (versão educacional)

email_padrao = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

emails_teste = [

"[email protected]",

"invalido@",

"sem_arroba.com",

"[email protected]"

]

for email in emails_teste:

if re.match(email_padrao, email):

print(f"✅ Válido: {email}")

else:

print(f"❌ Inválido: {email}")

# Validar telefone brasileiro (com ou sem DDD)

telefone_padrao = r'^($?\d{2}$?\s?)?9?\d{4}-\d{4}$'

telefones = [

"(11) 91234-5678",

"11912345678",

"91234-5678",

"1234-5678", # inválido (celular precisa do 9)

"(11) 1234-5678"

]

print("\n=== Validação de Telefones ===")

for tel in telefones:

if re.match(telefone_padrao, tel):

print(f"✅ Válido: {tel}")

else:

print(f"❌ Inválido: {tel}")

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

# EXEMPLO 2: EXTRAÇÃO DE DADOS

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

print("\n=== Extração de Dados ===")

texto = """

Data: 2024-01-15, venda de R$ 1.234,56 para cliente Ana.

Em 2024-02-20, valor de R$ 2.500,00 para Carlos.

Total do mês: R$ 12.345,67

"""

# Extrair todas as datas no formato YYYY-MM-DD

datas = re.findall(r'\d{4}-\d{2}-\d{2}', texto)

print(f"Datas encontradas: {datas}")

# Extrair valores monetários (R$ 1.234,56)

valores = re.findall(r'R\$ [\d\.]+,\d{2}', texto)

print(f"Valores encontrados: {valores}")

# Extrair usando grupos (captura)

padrao_data_grupo = r'(\d{4})-(\d{2})-(\d{2})'

for data in re.finditer(padrao_data_grupo, texto):

ano, mes, dia = data.groups()

print(f"Data capturada -> Ano: {ano}, Mês: {mes}, Dia: {dia}")

# Nomear grupos (Python 3.8+)

padrao_nomeado = r'(?P\d{2})/(?P\d{2})/(?P\d{4})'

texto_data_br = "Ontem foi 15/03/2024 e hoje é 16/03/2024"

for match in re.finditer(padrao_nomeado, texto_data_br):

print(f"Dia: {match.group('dia')}, Mês: {match.group('mes')}, Ano: {match.group('ano')}")

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

# EXEMPLO 3: SUBSTITUIÇÕES COM re.sub()

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

print("\n=== Substituições ===")

# Esconder e-mails

texto_emails = "Contato: [email protected] ou [email protected]"

anonimizado = re.sub(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',

'[EMAIL OCULTO]', texto_emails)

print(f"Original: {texto_emails}")

print(f"Anonimizado: {anonimizado}")

# Limpar números de uma string

texto_sujo = "Pedido #1234 - Valor R$ 567,89"

apenas_numeros = re.sub(r'[^0-9]', '', texto_sujo)

print(f"Apenas números: {apenas_numeros}")

# Converter datas BR para ISO (função com re.sub)

def converter_iso(match):

dia, mes, ano = match.groups()

return f"{ano}-{mes}-{dia}"

texto_datas = "15/03/2024 e 20/12/2023"

iso_datas = re.sub(r'(\d{2})/(\d{2})/(\d{4})', converter_iso, texto_datas)

print(f"Datas em ISO: {iso_datas}")

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

# EXEMPLO 4: FLAGS E COMPILAÇÃO

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

print("\n=== Flags e Compilação ===")

# Case-insensitive (IGNORECASE)

texto_exemplo = "Python é PYTHON poderoso. python também."

python_comp = re.findall(r'python', texto_exemplo, re.IGNORECASE)

print(f"Pythons encontrados: {python_comp}")

# Busca multilinha (MULTILINE)

codigo = """

def funcao():

pass

class Teste:

pass

"""

# Encontrar linhas que começam com def ou class

padrao_inicio = r'^(def|class)\s+\w+'

encontrados = re.findall(padrao_inicio, codigo, re.MULTILINE)

print(f"Definições encontradas: {encontrados}")

# Compilar padrão para reutilização

padrao_compilado = re.compile(r'\b\w{3,5}\b', re.IGNORECASE)

palavras = padrao_compilado.findall("Python regex é muito útil para buscas complexas")

print(f"Palavras com 3-5 letras: {palavras}")

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

# EXEMPLO 5: EXEMPLOS PRÁTICOS COMUNS

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

print("\n=== Exemplos Práticos ===")

# Extrair todas as URLs de um texto

texto_urls = "Visite https://python.org e http://example.com ou www.google.com"

url_padrao = r'https?://[a-zA-Z0-9./-]+|www\.[a-zA-Z0-9./-]+'

urls = re.findall(url_padrao, texto_urls)

print(f"URLs encontradas: {urls}")

# Validar CPF (formato apenas, sem dígito verificador)

cpf_padrao = r'^\d{3}\.\d{3}\.\d{3}-\d{2}$'

cpfs = ["123.456.789-00", "11122233344", "abc.def.ghi-jk"]

for cpf in cpfs:

if re.match(cpf_padrao, cpf):

print(f"✅ CPF válido: {cpf}")

else:

print(f"❌ CPF inválido: {cpf}")

# Separar palavra em sílabas simples (educacional)

palavra = "programacao"

silabas = re.findall(r'[bcdfghjklmnpqrstvwyxz]*[aeiouáéíóú]+', palavra)

print(f"Sílabas de '{palavra}': {silabas}")

# Limpar caracteres especiais

texto_sujo = "Olá, como você está? Hoje é 15/03!"

limpo = re.sub(r'[^\w\s]', '', texto_sujo, encoding='utf-8')

print(f"Texto limpo (apenas letras/ números/ espaços): {limpo}")

Os exemplos mostram a versatilidade das expressões regulares. Com poucas linhas, resolvemos problemas complexos. Primeiramente, note os padrões com metacaracteres \d e \w. Eles simplificam muito a escrita das regexes. Além disso, as flags como re.IGNORECASE aumentam a flexibilidade. A compilação prévia com re.compile() melhora a performance. Isso é útil quando o mesmo padrão é usado várias vezes. Para validações em formulários, use re.match() ou re.fullmatch(). Para extrações repetidas, finditer() é mais eficiente. Portanto, escolha a função certa para cada tarefa. Isso foi pensado para otimizar o uso de memória e tempo.

Outro ponto crucial é o tratamento de caracteres especiais. Pontos, colchetes e parênteses precisam de escape com barra invertida. Por exemplo, \. busca um ponto literal. Esqueça isso e sua regex terá comportamento inesperado. Além disso, evite regex excessivamente longas. Elas são difíceis de depurar e manter. Primeiramente, divida problemas complexos em etapas. Use variáveis para construir padrões aos poucos. Comente suas regexes com detalhes significativos. No Python, use strings raw r"..." para evitar escapes duplicados. Assim, você mantém a sanidade mental do programador. Portanto, documente suas expressões regulares sempre.

📌 Metacaracteres mais comuns (resumo rápido):
. – qualquer caractere
\d – dígito (0-9)
\w – letra, número ou _
\s – espaço, tab ou quebra
^ – início da string
$ – fim da string
* – zero ou mais
+ – um ou mais
? – zero ou um
{n,m} – entre n e m vezes

Finalmente, lembre-se dos limites das expressões regulares. Elas não conseguem contar parênteses aninhados corretamente. Também falham em linguagens com palavras balanceadas. Para esses casos, use analisadores sintáticos específicos. Um exemplo clássico é HTML dentro de HTML. Regex não é a ferramenta correta para isso. Portanto, conheça o domínio do seu problema. Use regex para padrões regulares (daí o nome). Isso foi estabelecido pela teoria da computação. Respeite esses limites e você será bem-sucedido. Assim, regex será uma aliada, não uma dor de cabeça.