Um guia para expressões regulares do R

O conceito de expressões regulares, geralmente chamado de regex, existe em muitas linguagens de programação, como R, Python, C, C++, Perl, Java e JavaScript. Você pode acessar a funcionalidade do regex na versão básica dessas linguagens ou por meio de bibliotecas. Na maioria das linguagens de programação, a sintaxe dos padrões regex é semelhante.

Neste tutorial, exploraremos o que são expressões regulares em R, por que elas são importantes, quais ferramentas e funções nos permitem trabalhar com elas, quais padrões de regex são os mais comuns e como usá-los. No final, apresentaremos uma visão geral de alguns aplicativos avançados do R regex.

O que é R Regex e por que você deve usá-lo?

Uma expressão regular, regex, em R é uma sequência de caracteres (ou até mesmo um caractere) que descreve um determinado padrão encontrado em um texto. Os padrões Regex podem ser tão curtos quanto "a" ou tão longos quanto o mencionado neste tópico do StackOverflow.

Em termos gerais, a definição acima de regex está relacionada não apenas ao R, mas também a qualquer outra linguagem de programação que suporte expressões regulares.

O Regex é uma ferramenta muito flexível e poderosa, amplamente utilizada para processar e minerar dados de texto não estruturados. Por exemplo, eles são aplicados em mecanismos de pesquisa, análise lexical, filtragem de spam e editores de texto.

Ferramentas e funções para trabalhar com o R Regex

Embora os padrões regex sejam semelhantes na maioria das linguagens de programação, as funções para trabalhar com eles são diferentes.

No R, podemos usar as funções do R básico para detectar, combinar, localizar, extrair e substituir regex. Abaixo estão as principais funções que buscam correspondências de regex em um vetor de caracteres e, em seguida, fazem o seguinte:

• grep(), grepl() - retornam os índices das cadeias de caracteres que contêm uma correspondência (grep()) ou um vetor lógico que mostra quais cadeias de caracteres contêm uma correspondência (grepl()).
• regexpr(), gregexpr() - retornam o índice de cada cadeia de caracteres onde a correspondência começa e o comprimento dessa correspondência. Enquanto regexpr() fornece essas informações somente para a primeira correspondência (a partir da esquerda), gregexpr() faz o mesmo para todas as correspondências.
• sub(), gsub() - substitui uma correspondência detectada em cada string por uma string especificada (sub() - somente para a primeira correspondência, gsub() - para todas as correspondências).
• regexec() - funciona como regexpr(), mas retorna as mesmas informações também para uma subexpressão especificada dentro da correspondência.
• regmatches() - funciona como regexec(), mas retorna as cadeias de caracteres exatas detectadas para a correspondência geral e uma subexpressão especificada.

No entanto, em vez de usar as funções nativas do R, uma maneira mais conveniente e consistente de trabalhar com o R regex é usar um pacote stringr especializado da coleção tidyverse. Essa biblioteca foi criada com base no pacote stringi. Na biblioteca stringr, todas as funções começam com str_ e têm nomes muito mais intuitivos (bem como os nomes de seus parâmetros opcionais) do que os do R básico.

Para instalar e carregar o pacote stringr, execute o seguinte:

install.packages('stringr')
library(stringr)

A tabela abaixo mostra a correspondência entre as funções do stringr e as do R básico que discutimos anteriormente nesta seção:

Você pode encontrar uma lista completa das funções stringr e das expressões regulares nessas folhas de consulta, mas discutiremos algumas delas mais detalhadamente neste tutorial.

Observação: nas funções stringr, passamos primeiro os dados e, em seguida, uma regex, enquanto nas funções básicas do R - exatamente o contrário.

Padrões Regex R

Agora, vamos apresentar uma visão geral dos padrões regex mais populares do R e seu uso e, ao mesmo tempo, praticar algumas das funções stringr.

Antes de fazer isso, vamos dar uma olhada em um exemplo bem básico. Ou seja, vamos verificar se um unicórnio tem pelo menos um milho 😉

str_detect('unicorn', 'corn')

Saída:

TRUE

Neste exemplo, usamos a função str_detect() stringr para verificar a presença da string corn na string unicorn.

No entanto, normalmente, não estamos procurando uma determinada cadeia literal em um texto, mas sim um determinado padrão - uma expressão regular. Vamos nos aprofundar e explorar esses padrões.

Fugas de personagens

Há alguns caracteres que têm um significado especial quando usados em expressões regulares do R. Mais precisamente, eles não combinam entre si, como fazem todas as letras e dígitos, mas fazem algo diferente:

str_extract_all('unicorn', '.')

Saída:

1. 'u' 'n' 'i' 'c' 'o' 'r' 'n'

Vemos claramente que não há pontos em nosso unicórnio. No entanto, a função str_extract_all() extraiu todos os caracteres dessa string. Essa é a missão exata do caractere . - corresponder a qualquer caractere único, exceto uma nova linha.

E se quisermos extrair um ponto literal? Para isso, temos que usar um caractere de escape regex antes do ponto - uma barra invertida (\). No entanto, é preciso ter em mente uma armadilha: a barra invertida também é usada nas próprias cadeias de caracteres como um caractere de escape. Isso significa que primeiro precisamos "escapar do caractere de escape", usando uma barra invertida dupla. Vamos ver como isso funciona:

str_extract_all('Eat. Pray. Love.', '\\.')

Saída:

1. '.' '.' '.'

Portanto, a barra invertida ajuda a negligenciar um significado especial de alguns símbolos nas expressões regulares do R e a interpretá-los literalmente. Ele também tem a missão oposta: dar um significado especial a alguns caracteres que, de outra forma, seriam interpretados literalmente. Abaixo está uma tabela com as sequências de escape de caracteres mais usadas:

Vamos dar uma olhada em alguns exemplos, tendo em mente que, também nesses casos, precisamos usar uma barra invertida dupla. Ao mesmo tempo, apresentaremos mais duas funções stringr: str_view() e str_view_all() (para visualizar a renderização HTML da primeira correspondência ou de todas as correspondências):

str_view('Unicorns are so cute!', 's\\b')
str_view('Unicorns are so cute!', 's\\B')

Saída:

Os unicórnios são tão fofos!

Os unicórnios são tãofofos!

No texto Unicorns are so cute!, há duas ocorrências da letra s. Acima, o primeiro padrão regex R destacou a primeira instância da letra s (já que ela é seguida por um espaço), enquanto o segundo - a segunda instância (já que ela é seguida por outra letra, não por um limite de palavra).

Mais alguns exemplos:

cat('Unicorns are\nso cute!')
str_view_all('Unicorns are\nso cute!', '\\n')

Saída:

Unicorns are
so cute!

Os unicórnios sãotão fofos!

cat('Unicorns are\tso cute!')
str_view_all('Unicorns are\tso cute!', '\\t')

Saída:

Unicorns are so    cute!

Os unicórnios sãotão fofos!

Classes de personagens

Uma classe de caracteres corresponde a qualquer caractere de um conjunto predefinido de caracteres. As classes de caracteres incorporadas têm a mesma sintaxe das sequências de escape de caracteres que vimos na seção anterior: uma barra invertida seguida de uma letra à qual ela dá um significado especial em vez do literal. As construções mais populares são apresentadas a seguir:

Vamos dar uma olhada em alguns exemplos autoexplicativos:

str_view_all('Unicorns are so cute!', '\\w')
str_view_all('Unicorns are so cute!', '\\W')

Saída:

Os unicórnios são tão fofos!

Unicorns_are_so_cute!

str_view_all('Unicorns are\nso cute!', '\\s')
str_view_all('Unicorns are\nso cute!', '\\S')

Saída:

Unicórnios_são_tão_fofos!

Unicórnios são muito fofos!

str_detect('Unicorns are so cute!', '\\d')

Saída:

FALSE

As classes de caracteres incorporadas também podem aparecer em uma forma alternativa - [:character_class_name:]. Algumas dessas classes de caracteres têm um equivalente entre aquelas com uma barra invertida, outras não. Os mais comuns são:

Vamos explorar alguns exemplos, tendo em mente que precisamos colocar qualquer um dos padrões de regex R acima entre colchetes:

str_view('Unicorns are so cute!', '[[:upper:]]')
str_view('Unicorns are so cute!', '[[:lower:]]')

Saída:

Os unicórniossão tão fofos!

Os unicórniossão tão fofos!

str_detect('Unicorns are so cute!', '[[:digit:]]')

Saída:

FALSE

str_extract_all('Unicorns are so cute!', '[[:punct:]]')

Saída:

1. '!'

str_view_all('Unicorns are so cute!', '[[:space:]]')

Saída:

Unicórnios_são_tão_fofos!

Também é possível criar uma classe de caracteres definida pelo usuário, colocando entre colchetes qualquer conjunto de caracteres do qual queremos fazer a correspondência com qualquer caractere. Podemos colocar entre colchetes um intervalo de letras ou números (em ordem Unicode), vários intervalos diferentes ou qualquer conjunto sequencial ou não sequencial de caracteres ou grupos de caracteres.

Por exemplo, [A-D] corresponderá a qualquer letra maiúscula de A a D, inclusive, [k-r] - qualquer letra minúscula de k a r, inclusive,[0-7] - qualquer dígito de 0 a 7, inclusive, e [aou14%9] - qualquer um dos caracteres fornecidos entre colchetes. Se colocarmos o acento circunflexo (^) como o primeiro caractere dentro de colchetes, nosso padrão regex R corresponderá a tudo, exceto aos caracteres fornecidos. Observe que os mecanismos de correspondência acima diferenciam maiúsculas de minúsculas.

str_view_all('Unicorns Are SOOO Cute!', '[O-V]')
str_view_all('Unicorns Are SOOO Cute!', '[^O-V]')

Saída:

Os unicórniossão MUITO fofos!

Os unicórnios são MUITO fofos!

str_view_all('3.14159265359', '[0-2]')

Saída:

3.14159265359

str_view_all('The number pi is equal to 3.14159265359', '[n2e9&]')

Saída:

Onúmeropi é iguala 3,14159265359

Quantificadores

Muitas vezes, precisamos fazer a correspondência de um determinado padrão regex R repetidamente, em vez de apenas uma vez. Para isso, usamos quantificadores. Um quantificador sempre vai depois do padrão regex ao qual está relacionado. Os quantificadores mais comuns são apresentados na tabela abaixo:

Vamos experimentar todos eles:

str_extract('dog', 'dog\\d*')

Saída:

'dog'

Obtivemos a string dog inicial: não há dígitos no final dessa string, mas estamos bem com isso (0 ou mais instâncias de dígitos).

str_extract('12345', '\\d+')

Saída:

'12345'

str_extract('12345', '\\d?')

Saída:

'1'

str_extract('12345', '\\d{3}')

Saída:

'123'

str_extract('12345', '\\d{7,}')

Saída:

NA

Recebemos NA porque não temos pelo menos 7 dígitos na string, apenas 5 deles.

str_extract('12345', '\\d{2,4}')

Saída:

'1234'

Âncoras

Por padrão, o R regex corresponderá a qualquer parte de uma string fornecida. Podemos alterar esse comportamento especificando uma determinada posição de um padrão regex R dentro da string. Na maioria das vezes, podemos querer impor a correspondência a partir do início ou do fim da cadeia de caracteres. Para isso, usamos as duas principais âncoras nas expressões regulares do R:

• ^ - corresponde ao início da cadeia de caracteres (para cadeias de caracteres de várias linhas - o início de cada linha)
• $ - corresponde a partir do final da cadeia de caracteres (para cadeias de caracteres de várias linhas - o final de cada linha)

Vamos ver como eles funcionam no exemplo de um palíndromo em que Stella não ganhou nenhuma carteira:

str_view('stella won no wallets', '^s')
str_view('stella won no wallets', 's$')

Saída:

stellanão ganhou carteiras

stella não ganhou carteiras

Se quisermos combinar os caracteres ^ ou $, precisamos preceder o caractere de interesse com uma barra invertida(duplicando-o):

str_view_all('Do not have 100$, have 100 friends', '\\$')

Saída:

Não tenha 100 dólares, tenha 100 amigos

Também é possível ancorar correspondências em limites de palavras ou não palavras dentro da cadeia de caracteres(\b e \B, respectivamente):

str_view_all('road cocoa oasis oak boa coach', '\\boa')
str_view_all('road cocoa oasis oak boa coach', 'oa\\b')
str_view_all('road cocoa oasis oak boa coach', 'oa\\B')

Saída:

road cocoa oasis oakboa coach

roadcocoa oasis oakboa coach

roadcocoa oasis oakboacoach

Acima, combinamos a combinação de letras oa:

• 1º exemplo - no início das palavras
• 2º exemplo - no final das palavras
• 3º exemplo - sempre que for seguido por um caractere de palavra (no nosso caso - por uma letra)

Alternância

Aplicando o operador de alternância(|), podemos fazer a correspondência de mais de um padrão regex R na mesma string. Observe que, se usarmos esse operador como parte de uma classe de caracteres definida pelo usuário, ele será interpretado literalmente e, portanto, não realizará nenhuma alternância.

str_view_all('coach koala board oak cocoa road boa load coat oasis boat', 'boa|coa')

Saída:

coachkoala boardoakcocoa road boa load coatoasis boat

No exemplo acima, fizemos a correspondência de todas as instâncias de boa ou coa.

Agrupamento

Os padrões regex do R seguem determinadas regras de precedência. Por exemplo, a repetição (usando quantificadores) é priorizada em relação à ancoragem, enquanto a ancoragem tem precedência sobre a alternância. Para substituir essas regras e aumentar a precedência de uma determinada operação, devemos usar o agrupamento. Isso pode ser feito colocando uma subexpressão de interesse entre colchetes.

O agrupamento funciona melhor em combinação com o operador de alternância. Os exemplos abaixo demonstram claramente o efeito dessa combinação:

str_view_all('code rat coat cot cat', 'co|at')
str_view_all('code rat coat cot cat', 'c(o|a)t')

Saída:

códigorat coat cotcat

código rat coat cot cat

Aplicativos avançados de expressões regulares do R

Tudo o que discutimos até agora nos dá uma boa base para começar a trabalhar com expressões regulares do R. No entanto, há muito mais coisas que podemos fazer com essa ferramenta poderosa. Sem entrar em detalhes, vamos mencionar apenas algumas operações avançadas que podemos realizar com o R regex:

• Substituir os padrões das funções stringr
• Agrupamentos de grafemas correspondentes
• Referência de grupo
• Correspondência de propriedades Unicode
• Aplicação de escape avançado de caracteres
• Verificar a existência de um padrão sem incluí-lo na saída (os chamados lookarounds)
• Tornar o mecanismo de repetição de padrões preguiçoso em vez de ganancioso
• Trabalho com grupos atômicos

Saiba mais em nosso curso Intermediate Regular Expressions in R (Expressões regulares intermediárias no R).

Desafio R Regex

Agora é sua vez de praticar os padrões de regex do R que discutimos neste tutorial. Para isso, use nosso conjunto de dados : Internet News and Consumer Engagement, e tente fazer o seguinte: extraia os domínios de nível superior (TLDs) de todos os URLs. Alguns exemplos de TLDs são com, net, uk, etc.

Há mais de uma abordagem para concluir essa tarefa, incluindo soluções elegantes e compactas de uma linha (dica: você pode aprender mais sobre lookarounds no R regex mencionado na seção anterior e usá-las para resolver esse problema). Considere as seguintes orientações muito vagas para uma abordagem relativamente "iniciante":

• Inspecione algumas URLs no conjunto de dados e observe quais padrões estão sempre presentes em qualquer URL antes do TLD e quais são opcionais
• Observe se há algum padrão obrigatório em qualquer URL após o TLD (e, em caso afirmativo, quais) e quais padrões são opcionais
• Remover tudo antes do TLD do URL
• Remova tudo após o TLD do URL

Para resolver o problema usando o algoritmo acima, você não precisa fazer ou aprender nada adicional. Basta atualizar tudo o que discutimos neste tutorial e colocar seu conhecimento em prática. Em particular, você precisará das funções stringr, escapes de caracteres, classes de caracteres, quantificadores e agrupamento.

Bônus: Desafio nº 2

Se você quiser praticar mais, desta vez sem dicas, tente fazer o seguinte: usando o mesmo conjunto de dados do desafio anterior, extraia os nomes de domínio de todos os URLs. Um exemplo de um nome de domínio é o Google no URL www.google.com.

Conclusão

Para concluir, neste tutorial, aprendemos muitas coisas sobre expressões regulares do R. Em particular, discutimos:

• O que é o R regex
• Por que eles são importantes e onde são aplicados
• Quais funções (tanto do R nativo quanto de uma biblioteca especializada) são usadas para trabalhar com expressões regulares do R
• Os padrões regex mais comuns do R e seu escopo, nuances e armadilhas
• Quando e como usar escapes de caracteres, classes de caracteres, quantificadores, âncoras, alternância e agrupamento com o R regex
• Vários exemplos de aplicação de regex e funções do R
• Algumas operações avançadas com expressões regulares R

Essas habilidades e noções o ajudarão a trabalhar no R e em muitas outras linguagens de programação, pois o conceito de expressões regulares é o mesmo em todas essas linguagens e a sintaxe do regex é bastante semelhante na maioria delas.

Se você estiver interessado em dominar suas habilidades em R, considere explorar os seguintes cursos, trilhas de habilidades e artigos do DataCamp:

• Introdução ao R
• Intermediário R
• Programação R
• Importação e limpeza de dados com o R
• As 10 principais ideias de projetos de R para 2022
• O que é o R? - A potência da computação estatística
• Como começar a usar o R