16  Expressões Regulares (Regex) - Capítulo Bônus

De detetive com lupa para caçador de padrões: encontrando o que você precisa no texto!

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

1. O que são Expressões Regulares e quando usar essa ferramenta
2. Padrões básicos: metacaracteres essenciais (., *, +, ?, [], ^, $)
3. Classes de caracteres: , e suas variações
4. Quantificadores: como especificar quantas vezes um padrão deve aparecer
5. Módulo re: como usar regex em Python
6. Validação prática: emails, CPFs, telefones e outros formatos
7. Extração de dados: como extrair informações específicas de textos
8. Aplicações reais: regex em web scraping, APIs e processamento de dados

🎓 Vindo do Capítulo 15? Perfeito! Agora que você domina bancos de dados, vamos aprender a encontrar padrões em textos!

🎯 Meta: Ao final deste capítulo, você vai conseguir usar regex para validar dados, extrair informações e processar textos de forma eficiente.

⚠️ Por que isso importa: Regex é uma ferramenta poderosa mas pode ser complexa! Comece com padrões simples e vá progredindo gradualmente.

16.2 De Detetive com Lupa para Caçador de Padrões

Imagine que você é um detetive investigando um caso:

1. Evidências (Texto): Documentos, mensagens, relatórios
2. Padrões suspeitos: Sequências que se repetem
3. Lupa (Regex): Ferramenta para encontrar padrões específicos
4. Descobertas: Informações importantes encontradas

Em programação, funciona assim:

1. Texto: Dados que você quer analisar
2. Padrões: Sequências que você quer encontrar
3. Regex: Ferramenta para buscar padrões
4. Resultados: Informações extraídas ou validadas

16.2.1 O que são Expressões Regulares?

Regex é uma linguagem para descrever padrões em texto.

É como dar instruções para um assistente:

• 🔍 “Encontre todos os números de telefone”
• 📧 “Valide se este email está correto”
• 📅 “Extraia todas as datas do texto”
• 🔗 “Encontre todos os links”

16.2.2 Quando usar Regex?

• ✅ Validação: Verificar se dados estão no formato correto
• ✅ Extração: Encontrar informações específicas em textos
• ✅ Substituição: Trocar partes do texto por outras
• ✅ Limpeza: Remover caracteres indesejados
• ✅ Análise: Contar ocorrências de padrões

16.2.3 Exemplo prático

Sem regex (problema):

# Validar email manualmente (difícil!)
email = "usuario@email.com"
if "@" in email and "." in email.split("@")[1]:
    print("Email válido")

Com regex (solução):

import re
email = "usuario@email.com"
if re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
    print("Email válido")

💡 Exemplo: Google, Facebook e muitos sites usam regex para validar formulários e processar dados!

16.3 Padrões Básicos e Módulo re

16.3.1 Metacaracteres Essenciais

Símbolo	Significado	Exemplo
.	Qualquer caractere	c.t → cat, cut, cot
*	Zero ou mais	ab* → a, ab, abb, abbb
+	Um ou mais	ab+ → ab, abb, abbb
?	Zero ou um	ab? → a, ab
[]	Conjunto de caracteres	[abc] → a, b ou c
^	Início da string	^abc → strings que começam com abc
$	Fim da string	abc$ → strings que terminam com abc

16.3.2 Classes de Caracteres

Classe	Significado	Equivale a
\d	Dígito	[0-9]
\w	Letra, dígito ou _	[a-zA-Z0-9_]
\s	Espaço em branco	[ \t\n\r]
\D	Não dígito	[^0-9]
\W	Não alfanumérico	[^a-zA-Z0-9_]
\S	Não espaço	[^ \t\n\r]

16.3.3 Usando o Módulo re

import re

# Buscar primeira ocorrência
texto = "Meu telefone é (11) 99999-9999"
telefone = re.search(r'\(\d{2}\) \d{5}-\d{4}', texto)
if telefone:
    print(f"Telefone encontrado: {telefone.group()}")

# Buscar todas as ocorrências
texto = "Emails: joao@email.com, maria@teste.com, pedro@site.org"
emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', texto)
print(f"Emails encontrados: {emails}")

# Substituir texto
texto = "Preço: R$ 100,00 e R$ 200,00"
novo_texto = re.sub(r'R\$ \d+,\d{2}', 'R$ XXX,XX', texto)
print(f"Texto modificado: {novo_texto}")

16.3.4 Validação Prática

def validar_email(email):
    """Valida formato de email"""
    padrao = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(padrao, email))

def validar_telefone(telefone):
    """Valida formato de telefone brasileiro"""
    padrao = r'^\(\d{2}\) \d{4,5}-\d{4}$'
    return bool(re.match(padrao, telefone))

def validar_cpf(cpf):
    """Valida formato de CPF"""
    padrao = r'^\d{3}\.\d{3}\.\d{3}-\d{2}$'
    return bool(re.match(padrao, cpf))

# Testando
print(validar_email("usuario@email.com"))  # True
print(validar_telefone("(11) 99999-9999"))  # True
print(validar_cpf("123.456.789-00"))  # True

16.3.5 Extração de Dados

def extrair_dados(texto):
    """Extrai diferentes tipos de dados de um texto"""
    dados = {}
    
# Extrair emails
    emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', texto)
    dados['emails'] = emails
    
# Extrair telefones
    telefones = re.findall(r'\(\d{2}\) \d{4,5}-\d{4}', texto)
    dados['telefones'] = telefones
    
# Extrair datas (formato dd/mm/aaaa)
    datas = re.findall(r'\d{2}/\d{2}/\d{4}', texto)
    dados['datas'] = datas
    
# Extrair URLs
    urls = re.findall(r'https?://[^\s]+', texto)
    dados['urls'] = urls
    
    return dados

# Exemplo de uso
texto = """
Contato: joao@email.com, telefone (11) 99999-9999
Site: https://www.exemplo.com
Data: 15/12/2024
"""

dados = extrair_dados(texto)
for tipo, valores in dados.items():
    print(f"{tipo.title()}: {valores}")

💡 Dica: Comece com padrões simples e vá testando! Use ferramentas online como regex101.com para testar seus padrões.

16.4 Exercícios Práticos

16.4.1 MUITO FÁCIL (Nível 1)

1. Crie uma função que encontra todos os números em um texto.

2. Valide se uma string contém apenas letras e espaços.

3. Encontre todas as palavras que começam com “Python” em um texto.

4. Substitua todas as ocorrências de “erro” por “problema” em um texto.

5. Conte quantas vezes a palavra “Python” aparece em um texto.

16.4.2 FÁCIL (Nível 2)

6. Crie uma função que valida formato de data (dd/mm/aaaa).

7. Extraia todos os números de telefone de um texto.

8. Valide se uma senha tem pelo menos 8 caracteres e contém números.

9. Encontre todas as URLs em um texto.

10. Limpe um texto removendo caracteres especiais, mantendo apenas letras e números.

16.4.3 MÉDIO (Nível 3)

11. Crie um validador de CPF que verifica formato e dígitos verificadores.

12. Extraia informações de contato (nome, email, telefone) de um texto.

13. Valide formato de CEP brasileiro (00000-000).

14. Encontre todas as datas em diferentes formatos (dd/mm/aaaa, dd-mm-aaaa).

15. Crie uma função que formata números de telefone para o padrão brasileiro.

16.4.4 DIFÍCIL (Nível 4)

16. Implemente um parser de logs que extrai informações específicas.

17. Crie um sistema de validação de formulários com múltiplos campos.

18. Extraia dados estruturados de páginas HTML usando regex.

19. Implemente um sistema de busca avançada em textos.

20. Crie um validador de CNPJ com verificação de dígitos.

16.4.5 MUITO DIFÍCIL (Nível 5)

21. Implemente um sistema de análise de sentimentos usando regex.

22. Crie um parser de configurações que converte texto em estruturas de dados.

23. Implemente um sistema de tradução automática de padrões.

24. Crie um validador de documentos brasileiros (CPF, CNPJ, RG, etc.).

25. Implemente um sistema de extração de dados de contratos legais.

🎯 Dica: Regex pode ser complexa! Use ferramentas online para testar seus padrões e comece sempre com casos simples!

16.5 Respostas dos Exercícios

16.5.1 MUITO FÁCIL (Nível 1)

1. Encontrar todos os números em um texto

import re

def encontrar_numeros(texto):
    """Encontra todos os números em um texto"""
    numeros = re.findall(r'\d+', texto)
    return numeros

# Exemplo de uso
texto = "Eu tenho 25 anos e 3 irmãos, moro no número 123 da rua ABC."
numeros = encontrar_numeros(texto)
print(f"Números encontrados: {numeros}")

Explicação linha por linha:

• Linha 1: import re - Importa módulo de expressões regulares
• Linha 3: def encontrar_numeros(texto): - Define função para encontrar números
• Linha 4: """Encontra todos os números em um texto""" - Docstring explicando função
• Linha 5: numeros = re.findall(r'\d+', texto) - Usa regex para encontrar todos os números
• Linha 6: return numeros - Retorna lista de números encontrados
• Linha 8: # Exemplo de uso - Comentário explicativo
• Linha 9: texto = "Eu tenho 25 anos e 3 irmãos, moro no número 123 da rua ABC." - Texto de exemplo
• Linha 10: numeros = encontrar_numeros(texto) - Chama função para encontrar números
• Linha 11: print(f"Números encontrados: {numeros}") - Imprime resultado

2. Validar string com apenas letras e espaços

def validar_apenas_letras_espacos(texto):
    """Valida se string contém apenas letras e espaços"""
    padrao = r'^[a-zA-Z\s]+$'
    return bool(re.match(padrao, texto))

# Testando
testes = ["João Silva", "Maria 123", "Ana-Costa", "Pedro Santos"]
for teste in testes:
    resultado = "Válido" if validar_apenas_letras_espacos(teste) else "Inválido"
    print(f"'{teste}': {resultado}")

Explicação linha por linha:

• Linha 1: def validar_apenas_letras_espacos(texto): - Define função para validar texto
• Linha 2: """Valida se string contém apenas letras e espaços""" - Docstring explicando função
• Linha 3: padrao = r'^[a-zA-Z\s]+$' - Define padrão regex para letras e espaços
• Linha 4: return bool(re.match(padrao, texto)) - Retorna True se texto corresponde ao padrão
• Linha 6: # Testando - Comentário explicativo
• Linha 7: testes = ["João Silva", "Maria 123", "Ana-Costa", "Pedro Santos"] - Lista de textos para testar
• Linha 8: for teste in testes: - Percorre cada texto de teste
• Linha 9: resultado = "Válido" if validar_apenas_letras_espacos(teste) else "Inválido" - Determina resultado
• Linha 10: print(f"'{teste}': {resultado}") - Imprime resultado do teste

3. Encontrar palavras que começam com “Python”

def encontrar_palavras_python(texto):
    """Encontra todas as palavras que começam com Python"""
    padrao = r'\bPython\w*\b'
    palavras = re.findall(padrao, texto)
    return palavras

# Exemplo de uso
texto = "Python é uma linguagem Pythonica. Pythonista usa Python para programar."
palavras = encontrar_palavras_python(texto)
print(f"Palavras encontradas: {palavras}")

Explicação linha por linha:

• Linha 1: def encontrar_palavras_python(texto): - Define função para encontrar palavras Python
• Linha 2: """Encontra todas as palavras que começam com Python""" - Docstring explicando função
• Linha 3: padrao = r'\bPython\w*\b' - Define padrão regex para palavras começando com Python
• Linha 4: palavras = re.findall(padrao, texto) - Encontra todas as ocorrências do padrão
• Linha 5: return palavras - Retorna lista de palavras encontradas
• Linha 7: # Exemplo de uso - Comentário explicativo
• Linha 8: texto = "Python é uma linguagem Pythonica. Pythonista usa Python para programar." - Texto de exemplo
• Linha 9: palavras = encontrar_palavras_python(texto) - Chama função para encontrar palavras
• Linha 10: print(f"Palavras encontradas: {palavras}") - Imprime resultado

4. Substituir “erro” por “problema”

def substituir_erro_por_problema(texto):
    """Substitui todas as ocorrências de 'erro' por 'problema'"""
    novo_texto = re.sub(r'\berro\b', 'problema', texto, flags=re.IGNORECASE)
    return novo_texto

# Exemplo de uso
texto = "Encontrei um erro no código. Este erro precisa ser corrigido."
novo_texto = substituir_erro_por_problema(texto)
print(f"Texto original: {texto}")
print(f"Texto modificado: {novo_texto}")

Explicação linha por linha:

• Linha 1: def substituir_erro_por_problema(texto): - Define função para substituir texto
• Linha 2: """Substitui todas as ocorrências de 'erro' por 'problema'""" - Docstring explicando função
• Linha 3: novo_texto = re.sub(r'\berro\b', 'problema', texto, flags=re.IGNORECASE) - Substitui texto usando regex
• Linha 4: return novo_texto - Retorna texto modificado
• Linha 6: # Exemplo de uso - Comentário explicativo
• Linha 7: texto = "Encontrei um erro no código. Este erro precisa ser corrigido." - Texto de exemplo
• Linha 8: novo_texto = substituir_erro_por_problema(texto) - Chama função para substituir texto
• Linha 9: print(f"Texto original: {texto}") - Imprime texto original
• Linha 10: print(f"Texto modificado: {novo_texto}") - Imprime texto modificado

5. Contar ocorrências da palavra “Python”

def contar_python(texto):
    """Conta quantas vezes a palavra Python aparece no texto"""
    padrao = r'\bPython\b'
    matches = re.findall(padrao, texto)
    return len(matches)

# Exemplo de uso
texto = "Python é uma linguagem. Python é poderosa. Pythonista usa Python."
contagem = contar_python(texto)
print(f"A palavra 'Python' aparece {contagem} vezes no texto.")

Explicação linha por linha:

• Linha 1: def contar_python(texto): - Define função para contar palavra Python
• Linha 2: """Conta quantas vezes a palavra Python aparece no texto""" - Docstring explicando função
• Linha 3: padrao = r'\bPython\b' - Define padrão regex para palavra exata Python
• Linha 4: matches = re.findall(padrao, texto) - Encontra todas as ocorrências do padrão
• Linha 5: return len(matches) - Retorna quantidade de ocorrências encontradas
• Linha 7: # Exemplo de uso - Comentário explicativo
• Linha 8: texto = "Python é uma linguagem. Python é poderosa. Pythonista usa Python." - Texto de exemplo
• Linha 9: contagem = contar_python(texto) - Chama função para contar ocorrências
• Linha 10: print(f"A palavra 'Python' aparece {contagem} vezes no texto.") - Imprime resultado

16.5.2 FÁCIL (Nível 2)

6. Validar formato de data (dd/mm/aaaa)

def validar_data(data):
    """Valida formato de data dd/mm/aaaa"""
    padrao = r'^\d{2}/\d{2}/\d{4}$'
    if not re.match(padrao, data):
        return False
    
    # Verificar se é uma data válida
    try:
        dia, mes, ano = data.split('/')
        dia, mes, ano = int(dia), int(mes), int(ano)
        
        if mes < 1 or mes > 12:
            return False
        if dia < 1 or dia > 31:
            return False
        if ano < 1900 or ano > 2100:
            return False
            
        return True
    except ValueError:
        return False

# Testando
datas = ["15/12/2024", "32/01/2024", "15/13/2024", "29/02/2024", "01/01/2023"]
for data in datas:
    resultado = "Válida" if validar_data(data) else "Inválida"
    print(f"Data '{data}': {resultado}")

Explicação linha por linha:

• Linha 1: def validar_data(data): - Define função para validar data
• Linha 2: """Valida formato de data dd/mm/aaaa""" - Docstring explicando função
• Linha 3: padrao = r'^\d{2}/\d{2}/\d{4}$' - Define padrão regex para formato de data
• Linha 4: if not re.match(padrao, data): - Verifica se data corresponde ao formato
• Linha 5: return False - Retorna False se formato está incorreto
• Linha 7: # Verificar se é uma data válida - Comentário explicativo
• Linha 8: try: - Inicia bloco try para tratamento de erros
• Linha 9: dia, mes, ano = data.split('/') - Divide data em partes
• Linha 10: dia, mes, ano = int(dia), int(mes), int(ano) - Converte para números inteiros
• Linha 12: if mes < 1 or mes > 12: - Verifica se mês está no intervalo válido
• Linha 13: return False - Retorna False se mês é inválido
• Linha 14: if dia < 1 or dia > 31: - Verifica se dia está no intervalo válido
• Linha 15: return False - Retorna False se dia é inválido
• Linha 16: if ano < 1900 or ano > 2100: - Verifica se ano está no intervalo válido
• Linha 17: return False - Retorna False se ano é inválido
• Linha 19: return True - Retorna True se data é válida
• Linha 20: except ValueError: - Captura erro de conversão
• Linha 21: return False - Retorna False em caso de erro

7. Extrair números de telefone

def extrair_telefones(texto):
    """Extrai todos os números de telefone de um texto"""
    # Padrão para telefones brasileiros
    padrao = r'\(?\d{2}\)?[-.\s]?\d{4,5}[-.\s]?\d{4}'
    telefones = re.findall(padrao, texto)
    return telefones

# Exemplo de uso
texto = """
Contatos: (11) 99999-9999, 21 98765-4321, (85) 9123-4567
Telefones: 11 9999-9999, 21.98765.4321, (85)-9123-4567
"""
telefones = extrair_telefones(texto)
print(f"Telefones encontrados: {telefones}")

Explicação linha por linha:

• Linha 1: def extrair_telefones(texto): - Define função para extrair telefones
• Linha 2: """Extrai todos os números de telefone de um texto""" - Docstring explicando função
• Linha 3: # Padrão para telefones brasileiros - Comentário explicativo
• Linha 4: padrao = r'\(?\d{2}\)?[-.\s]?\d{4,5}[-.\s]?\d{4}' - Define padrão regex para telefones
• Linha 5: telefones = re.findall(padrao, texto) - Encontra todos os telefones no texto
• Linha 6: return telefones - Retorna lista de telefones encontrados
• Linha 8: # Exemplo de uso - Comentário explicativo
• Linha 9: texto = """ - Inicia string multilinha com texto de exemplo
• Linha 10: Contatos: (11) 99999-9999, 21 98765-4321, (85) 9123-4567 - Exemplo de telefones
• Linha 11: Telefones: 11 9999-9999, 21.98765.4321, (85)-9123-4567 - Mais exemplos
• Linha 12: """ - Fecha string multilinha
• Linha 13: telefones = extrair_telefones(texto) - Chama função para extrair telefones
• Linha 14: print(f"Telefones encontrados: {telefones}") - Imprime resultado

8. Validar senha forte

def validar_senha(senha):
    """Valida se senha tem pelo menos 8 caracteres e contém números"""
    # Verificar comprimento mínimo
    if len(senha) < 8:
        return False, "Senha deve ter pelo menos 8 caracteres"
    
    # Verificar se contém números
    if not re.search(r'\d', senha):
        return False, "Senha deve conter pelo menos um número"
    
    # Verificar se contém letras
    if not re.search(r'[a-zA-Z]', senha):
        return False, "Senha deve conter pelo menos uma letra"
    
    return True, "Senha válida"

# Testando
senhas = ["12345678", "abcdefgh", "senha123", "1234567", "Senha@123"]
for senha in senhas:
    valida, mensagem = validar_senha(senha)
    print(f"Senha '{senha}': {mensagem}")

Explicação linha por linha:

• Linha 1: def validar_senha(senha): - Define função para validar senha
• Linha 2: """Valida se senha tem pelo menos 8 caracteres e contém números""" - Docstring explicando função
• Linha 3: # Verificar comprimento mínimo - Comentário explicativo
• Linha 4: if len(senha) < 8: - Verifica se senha tem pelo menos 8 caracteres
• Linha 5: return False, "Senha deve ter pelo menos 8 caracteres" - Retorna erro se muito curta
• Linha 7: # Verificar se contém números - Comentário explicativo
• Linha 8: if not re.search(r'\d', senha): - Verifica se senha contém números
• Linha 9: return False, "Senha deve conter pelo menos um número" - Retorna erro se não tem números
• Linha 11: # Verificar se contém letras - Comentário explicativo
• Linha 12: if not re.search(r'[a-zA-Z]', senha): - Verifica se senha contém letras
• Linha 13: return False, "Senha deve conter pelo menos uma letra" - Retorna erro se não tem letras
• Linha 15: return True, "Senha válida" - Retorna sucesso se senha é válida
• Linha 17: # Testando - Comentário explicativo
• Linha 18: senhas = ["12345678", "abcdefgh", "senha123", "1234567", "Senha@123"] - Lista de senhas para testar
• Linha 19: for senha in senhas: - Percorre cada senha
• Linha 20: valida, mensagem = validar_senha(senha) - Chama função de validação
• Linha 21: print(f"Senha '{senha}': {mensagem}") - Imprime resultado da validação

9. Encontrar URLs

def encontrar_urls(texto):
    """Encontra todas as URLs em um texto"""
    padrao = r'https?://[^\s<>"{}|\\^`\[\]]+'
    urls = re.findall(padrao, texto)
    return urls

# Exemplo de uso
texto = """
Visite nosso site: https://www.exemplo.com
Também temos: http://blog.exemplo.com
E nossa API: https://api.exemplo.com/v1
"""
urls = encontrar_urls(texto)
print(f"URLs encontradas: {urls}")

Explicação linha por linha:

• Linha 1: def encontrar_urls(texto): - Define função para encontrar URLs
• Linha 2: """Encontra todas as URLs em um texto""" - Docstring explicando função
• Linha 3: padrao = r'https?://[^\s<>"{}|\\^[]]+’` - Define padrão regex para URLs
• Linha 4: urls = re.findall(padrao, texto) - Encontra todas as URLs no texto
• Linha 5: return urls - Retorna lista de URLs encontradas
• Linha 7: # Exemplo de uso - Comentário explicativo
• Linha 8: texto = """ - Inicia string multilinha com texto de exemplo
• Linha 9: Visite nosso site: https://www.exemplo.com - Exemplo de URL
• Linha 10: Também temos: http://blog.exemplo.com - Outro exemplo
• Linha 11: E nossa API: https://api.exemplo.com/v1 - Mais um exemplo
• Linha 12: """ - Fecha string multilinha
• Linha 13: urls = encontrar_urls(texto) - Chama função para encontrar URLs
• Linha 14: print(f"URLs encontradas: {urls}") - Imprime resultado

10. Limpar texto removendo caracteres especiais

def limpar_texto(texto):
    """Remove caracteres especiais, mantendo apenas letras e números"""
    # Substituir caracteres especiais por espaço
    texto_limpo = re.sub(r'[^a-zA-Z0-9\s]', ' ', texto)
    
    # Remover espaços extras
    texto_limpo = re.sub(r'\s+', ' ', texto_limpo)
    
    # Remover espaços no início e fim
    texto_limpo = texto_limpo.strip()
    
    return texto_limpo

# Exemplo de uso
texto = "Olá! Como você está? #Python é @incrível! 100% funcional."
texto_limpo = limpar_texto(texto)
print(f"Texto original: {texto}")
print(f"Texto limpo: {texto_limpo}")

Explicação linha por linha:

• Linha 1: def limpar_texto(texto): - Define função para limpar texto
• Linha 2: """Remove caracteres especiais, mantendo apenas letras e números""" - Docstring explicando função
• Linha 3: # Substituir caracteres especiais por espaço - Comentário explicativo
• Linha 4: texto_limpo = re.sub(r'[^a-zA-Z0-9\s]', ' ', texto) - Remove caracteres especiais
• Linha 5: # Remover espaços extras - Comentário explicativo
• Linha 6: texto_limpo = re.sub(r'\s+', ' ', texto_limpo) - Remove espaços múltiplos
• Linha 7: # Remover espaços no início e fim - Comentário explicativo
• Linha 8: texto_limpo = texto_limpo.strip() - Remove espaços nas bordas
• Linha 10: return texto_limpo - Retorna texto limpo
• Linha 12: # Exemplo de uso - Comentário explicativo
• Linha 13: texto = "Olá! Como você está? #Python é @incrível! 100% funcional." - Texto de exemplo
• Linha 14: texto_limpo = limpar_texto(texto) - Chama função para limpar texto
• Linha 15: print(f"Texto original: {texto}") - Imprime texto original
• Linha 16: print(f"Texto limpo: {texto_limpo}") - Imprime texto limpo

16.6 Próximos Passos: Continue Aprendendo!

Parabéns! Você agora domina expressões regulares com Python! 🎉

16.6.1 O que você aprendeu:

• ✅ Conceito de Regex: Como usar padrões para encontrar texto
• ✅ Metacaracteres básicos: ., *, +, ?, [], ^, $ e suas funções
• ✅ Classes de caracteres: , e suas variações
• ✅ Módulo re: Como usar regex em Python
• ✅ Validação prática: Emails, telefones, CPFs e outros formatos
• ✅ Extração de dados: Como encontrar informações específicas
• ✅ Substituição: Como modificar textos usando padrões
• ✅ Aplicações reais: Regex em validação e processamento de dados

16.6.2 Desafios para Continuar:

1. Pratique com dados reais: Use regex em projetos de web scraping
2. Crie validadores: Implemente sistemas de validação robustos
3. Automatize tarefas: Use regex para processar grandes volumes de texto
4. Contribua com projetos: Encontre projetos que precisam de processamento de texto

16.6.3 Parabéns! Você Completou o Livro!

Você agora domina 16 capítulos de Python, desde o básico até tópicos avançados:

Capítulos Fundamentais (1-10):

• Introdução ao ambiente e algoritmos
• Variáveis, I/O e estruturas de controle
• Funções, listas, dicionários e tuplas
• Manipulação de arquivos, POO e tratamento de erros

Capítulos Avançados (11-16):

• Módulos e bibliotecas
• APIs (consumo e criação)
• Web scraping
• Bancos de dados SQL
• Expressões regulares (bônus)

16.6.4 Próximos Passos na Jornada:

1. Projetos práticos: Aplique tudo que aprendeu em projetos reais
2. Frameworks: Explore Django, FastAPI, Pandas, NumPy
3. Especialização: Machine Learning, Data Science, Web Development
4. Contribuição: Participe de projetos open source
5. Comunidade: Compartilhe conhecimento e aprenda com outros

🎯 batel.tech: Continue sua jornada! Acesse batel.tech e encontre projetos práticos para aplicar todo seu conhecimento em Python! Lá você pode colaborar com outros desenvolvedores e construir aplicações incríveis!

---

16.7 Referências Bibliográficas

• Python re Module: Python Regular Expressions
• Regex Tutorial: Regular-Expressions.info
• Regex Testing: Regex101.com
• Python Regex Guide: Real Python Regex Guide
• Regex Patterns: RegexLib.com

---

Capítulo 16 (Bônus) concluído! 🎉 Parabéns por completar toda a jornada de aprendizado em Python! Agora você está pronto para criar aplicações profissionais e contribuir com a comunidade de desenvolvedores!