Neste capítulo, você irá explorar como aproveitar o poder das expressões regulares em cenários avançados de Python, incluindo o uso de funções aninhadas, inversão de strings e junção de strings. Essas técnicas permitem manipular e analisar dados de texto de forma mais eficiente e flexível, desbloqueando novas possibilidades para automação, limpeza de dados e correspondência de padrões complexos.

Você aprenderá como as expressões regulares podem:

• Aprimorar a funcionalidade de funções aninhadas para extrair ou transformar dados;
• Simplificar o processo de inversão de strings com base em padrões específicos;
• Permitir a junção dinâmica e personalizada de strings usando regras baseadas em padrões.

Dominar essas aplicações ajudará você a escrever códigos Python mais concisos, legíveis e poderosos para uma ampla variedade de tarefas do mundo real, desde o processamento de arquivos de log até a construção de pipelines de dados.

Utilizando Expressões Regulares em Funções Aninhadas

Ao utilizar expressões regulares em Python, frequentemente você define padrões e lógicas de busca dentro de funções. Em alguns casos, pode ser necessário usar expressões regulares dentro de funções aninhadas — funções definidas dentro de outras funções. Compreender como funcionam o escopo e o acesso a variáveis nesse contexto ajuda a escrever códigos claros e reutilizáveis.

Definição: Funções Aninhadas

Uma função aninhada é uma função definida dentro de outra função. A função interna pode acessar variáveis da função que a envolve devido ao escopo léxico do Python (também chamado de closure).

Escopo e Expressões Regulares

• A função interna pode utilizar padrões de expressões regulares e objetos compilados definidos na função externa;
• É possível passar correspondências ou resultados de expressões regulares da função externa para a interna para processamento adicional;
• Compilar um padrão regex na função externa melhora a eficiência se a função interna utilizar o mesmo padrão várias vezes.

Exemplo Prático: Filtrando e Extraindo Dados

Suponha que você queira processar uma lista de endereços de e-mail, filtrando os válidos e extraindo a parte do nome de usuário. Você pode usar uma função aninhada para encapsular a lógica de extração:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Pontos-chave:

• O pattern é compilado uma vez na função externa e reutilizado na função aninhada extract_username;
• A função interna acessa o padrão regex do escopo envolvente;
• Essa estrutura mantém o código organizado e eficiente, especialmente ao lidar com tarefas complexas de análise de dados.

Utilizar expressões regulares em funções aninhadas é uma técnica poderosa para construir códigos modulares e de fácil manutenção que processam dados de texto de forma eficiente.

Revertendo Strings em Python

Reverter uma string é uma tarefa comum ao processar dados de texto. Python oferece uma maneira simples de reverter strings usando slicing, e você também pode combinar isso com expressões regulares para manipulação avançada de texto.

Como Reverter uma String

Você pode reverter qualquer string em Python usando slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Explicação:

• text[::-1] cria uma nova string contendo todos os caracteres de text, mas em ordem reversa.

Cenários de Uso

Reverter strings é útil em diversas situações:

• Verificação se uma string é um palíndromo;
• Ocultação de informações sensíveis exibindo-as ao contrário;
• Criação de efeitos de texto divertidos para interfaces de usuário.

Combinando Regex com Reversão de String

Você pode usar expressões regulares para encontrar padrões específicos em uma string e, em seguida, reverter apenas essas partes. Isso é útil quando se deseja reverter certas palavras ou padrões, e não a string inteira.

Exemplo: Reverter Todas as Palavras que Começam com Letra Maiúscula

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Como funciona:

• O padrão regex \b[A-Z][a-zA-Z]*\b corresponde a palavras que começam com letra maiúscula.
• A função reverse_match reverte cada palavra encontrada.
• re.sub substitui cada correspondência pela sua versão invertida.

Combinar expressões regulares com reversão de strings permite realizar transformações complexas de texto de forma concisa e flexível.

Juntando Strings em Python

Juntar strings é uma tarefa comum ao trabalhar com dados de texto. Frequentemente é necessário combinar várias strings em uma só, como ao unir palavras, linhas ou resultados de uma busca com expressão regular.

Usando join() para Combinar uma Lista de Strings

O método str.join() é a forma padrão de concatenar uma lista de strings em uma única string. Você especifica uma string separadora e chama join() sobre ela com a lista que deseja combinar.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Pontos-chave sobre join():

• O separador (como espaço, vírgula ou quebra de linha) vem antes de .join();
• O argumento de join() deve ser um iterável de strings (como uma lista ou tupla);
• O resultado é uma única string contendo todos os itens, separados pelo separador escolhido.

Juntando Correspondências de Regex em uma Única String

Quando você usa a função re.findall(), ela retorna uma lista de todas as correspondências não sobrepostas. Você pode usar join() para combinar essas correspondências em uma única string.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Casos de uso comuns:

• Combinar todas as correspondências de regex em uma string separada por vírgulas;
• Unir linhas de texto em um único bloco;
• Criar linhas CSV a partir de listas de valores.

Juntar strings de forma eficiente ajuda a processar, exibir e armazenar dados de texto de maneira legível e estruturada.