Expressões Regulares: A Arte da Busca e Manipulação de Texto

As expressões regulares são poderosas ferramentas de busca e manipulação de texto, amplamente utilizadas em diversas áreas, incluindo o processamento de linguagem natural (PLN). Elas permitem que você defina padrões complexos de texto e realize operações avançadas, como validação de dados, extração de informações e substituição de caracteres.

No contexto do PLN, as expressões regulares desempenham um papel crucial na análise e manipulação de textos. Elas possibilitam a identificação de entidades nomeadas, a detecção de padrões em frases, a normalização de dados e muito mais. Com sua capacidade de lidar com a complexidade da linguagem natural, as expressões regulares se tornaram uma ferramenta indispensável para desenvolvedores e pesquisadores nessa área.

Exemplos de Padrões de Busca em Python

Para os nossos exemplos utilizaremos a biblioteca python re (regular expression).

1. Busca por um padrão simples:

import re

text = "O gato brinca com a bola."
pattern = "gato"
match = re.search(pattern, text)
if match:
    print("Padrão encontrado:", match.group())
else:
    print("Padrão não encontrado.")

Explicação: O código usa a função re.search() para procurar o padrão "gato" no texto "O gato brinca com a bola.". Se o padrão for encontrado, a função match.group() retorna a correspondência.

2. Busca por um padrão com metacaracteres:

import re

text = "123 Rua dos Bobos, número 0"
pattern = r"\d+"
matches = re.findall(pattern, text)
print("Números encontrados:", matches)

Explicação: O código usa a função re.findall() para encontrar todos os padrões que correspondem a um ou mais dígitos (\d+) no texto "123 Rua dos Bobos, número 0". O resultado é uma lista contendo todas as correspondências.

3. Busca por um padrão com repetição:

import re

text = "Hoje é um dia lindo!"
pattern = r"i{2}"
matches = re.findall(pattern, text)
print("Correspondências:", matches)

Explicação: O código usa a função re.findall() para encontrar todas as ocorrências do padrão "i{2}", que corresponde a duas letras “i” consecutivas, no texto "Hoje é um dia lindo!". O resultado é uma lista contendo todas as correspondências.

4. Busca por um padrão com alternância:

import re

text = "Gato, Rato, Pato"
pattern = r"G|R"
matches = re.findall(pattern, text)
print("Letras encontradas:", matches)

Explicação: O código usa a função re.findall() para encontrar todas as ocorrências do padrão "G|R", que corresponde à letra “G” ou à letra “R”, no texto "Gato, Rato, Pato". O resultado é uma lista contendo todas as correspondências.

5. Busca por um padrão com âncoras:

import re

text = "Python é uma linguagem incrível!"
pattern = r"^Python"
match = re.search(pattern, text)
if match:
    print("Padrão encontrado no início da string:", match.group())
else:
    print("Padrão não encontrado no início da string.")

Explicação: O código usa a função re.search() para procurar o padrão "^Python", que corresponde à palavra “Python” no início da string, no texto "Python é uma linguagem incrível!". A âncora ^ indica o início da string. Se o padrão for encontrado, a função match.group() retorna a correspondência.

6. Busca por um padrão com classes de caracteres:

import re

text = "Hoje é um dia lindo!"
pattern = r"[aeiou]"
matches = re.findall(pattern, text)
print("Vogais encontradas:", matches)

Explicação: O código usa a função re.findall() para encontrar todas as ocorrências de qualquer vogal ([aeiou]) no texto "Hoje é um dia lindo!". O resultado é uma lista contendo todas as correspondências.

7. Busca por um padrão com negação de classe de caracteres:

import re

text = "Hoje é um dia lindo!"
pattern = r"[^aeiou]"
matches = re.findall(pattern, text)
print("Consoantes encontradas:", matches)

Explicação: O código usa a função re.findall() para encontrar todas as ocorrências de qualquer caractere que não seja uma vogal ([^aeiou]) no texto "Hoje é um dia lindo!". O resultado é uma lista contendo todas as correspondências.

8. Busca por um padrão com intervalos:

import re

text = "Tenho 25 anos."
pattern = r"\d{2}"
match = re.search(pattern, text)
if match:
    print("Número encontrado:", match.group())
else:
    print("Número não encontrado.")

Explicação: O código usa a função re.search() para procurar o padrão "\d{2}", que corresponde a exatamente dois dígitos, no texto "Tenho 25 anos.". Se o padrão for encontrado, a função match.group() retorna a correspondência.

9. Busca por um padrão com grupos de captura:

import re

text = "Nome: João Silva, Idade: 30 anos."
pattern = r"(\w+) (\w+), Idade: (\d+)"
match = re.search(pattern, text)
if match:
    print("Nome:", match.group(1))
    print("Sobrenome:", match.group(2))
    print("Idade:", match.group(3))
else:
    print("Padrão não encontrado.")

Explicação: O código usa a função re.search() para procurar o padrão "(\w+) (\w+), Idade: (\d+)", que corresponde a um nome, um sobrenome e uma idade, no texto "Nome: João Silva, Idade: 30 anos.". Os grupos de captura () permitem acessar as correspondências individuais usando match.group(index).

10. Busca por um padrão com lookahead:

import re

text = "Hoje é um dia lindo! Amanhã será um dia ainda mais lindo."
pattern = r"lindo\b(?=.*ainda mais)"
match = re.search(pattern, text)
if match:
    print("Padrão encontrado:", match.group())
else:
    print("Padrão não encontrado.")

Explicação: O código usa a função re.search() para procurar o padrão "lindo\b(?=.*ainda mais)", que corresponde à palavra “lindo” seguida de um limite de palavra (\b) e um lookahead positivo ((?=.*ainda mais)) que verifica se a string contém “ainda mais” em algum lugar depois de “lindo”, no texto "Hoje é um dia lindo! Amanhã será um dia ainda mais lindo.". Se o padrão for encontrado, a função match.group() retorna a correspondência.

Tabela de Metacaracteres Comuns

• . – Corresponde a qualquer caractere, exceto nova linha.
• ^ – Indica o início de uma string.
• $ – Indica o final de uma string.
• * – Corresponde a zero ou mais ocorrências do padrão anterior.
• + – Corresponde a uma ou mais ocorrências do padrão anterior.
• ? – Corresponde a zero ou uma ocorrência do padrão anterior.
• {n} – Corresponde exatamente a n ocorrências do padrão anterior.
• {n,} – Corresponde a n ou mais ocorrências do padrão anterior.
• {n,m} – Corresponde entre n e m ocorrências do padrão anterior.
• [] – Define uma classe de caracteres, correspondendo a qualquer caractere dentro dos colchetes.
• [^] – Define uma classe de caracteres negada, correspondendo a qualquer caractere que não esteja dentro dos colchetes.
• | – Operador de alternância, corresponde a um padrão ou outro.
• () – Grupos de captura, permite agrupar padrões e capturar correspondências.
• \ – Escapa um metacaractere, permitindo que ele seja tratado como um caractere literal.

As expressões regulares são uma ferramenta poderosa e versátil no processamento de texto, especialmente no processamento de linguagem natural. Com a capacidade de definir padrões complexos e realizar buscas e manipulações de maneira eficiente, elas se tornaram essenciais para desenvolvedores e pesquisadores. Ao dominar o uso de expressões regulares em Python, você pode aprimorar suas habilidades de análise de texto e abrir portas para novas possibilidades em projetos de PLN. Continue explorando e praticando, e você rapidamente se tornará um especialista em expressões regulares!

Para mais conteúdo relacionado, não esqueça de visitar nossos posts aqui no Janela do Dev.