Tutorial de expressões regulares em Python

Expressões regulares, ou regex, são sequências de caracteres usadas para verificar se um determinado padrão existe em um texto (string) ou não. Se você já usou motores de busca, a função localizar e substituir de processadores de texto e editores — você já viu expressões regulares em ação. Elas são usadas no lado do servidor para validar o formato de e-mails e senhas em cadastros, para fazer parsing de arquivos de texto a fim de encontrar, substituir ou excluir certas strings, etc. Ajudam a manipular dados textuais — algo frequentemente necessário em projetos de ciência de dados com mineração de texto.

Este tutorial vai apresentar os principais conceitos de expressões regulares com Python. Você começa importando o re — a biblioteca do Python que dá suporte a regex. Em seguida, verá como caracteres básicos/ordinários são usados para fazer correspondências, e depois os coringas ou caracteres especiais. Na sequência, você aprende a usar repetições nas suas expressões. Também vai aprender a criar grupos e grupos nomeados para facilitar o acesso aos matches. Por fim, vai entender o conceito de matching guloso vs. não guloso.

Parece muita coisa, e por isso incluímos uma tabela resumo prática com definições curtas para ajudar você a fixar o conteúdo. Não deixe de conferir!

Este tutorial também cobre algumas funções úteis da biblioteca re, como: compile(), search(), findall(), sub() para buscar e substituir, split() e outras. Você também vai conhecer as flags de compilação para turbinar suas regex.

No final, há um estudo de caso — hora de colocar o que aprendeu em prática! Então vamos de regex...

Expressões regulares em Python

No Python, expressões regulares são suportadas pelo módulo re. Isso significa que, para usá-las nos seus scripts, você precisa importar o módulo com import:

import re

A biblioteca re no Python oferece várias funções que valem a pena dominar. Você verá algumas delas de perto neste tutorial.

Padrões básicos: caracteres ordinários

Você pode lidar facilmente com muitos padrões básicos em Python usando caracteres ordinários. Eles são as expressões regulares mais simples. Correspondem a si mesmos, literalmente, e não têm significado especial na sintaxe de regex.

Exemplos: 'A', 'a', 'X', '5'.

Caracteres ordinários podem ser usados para correspondências exatas simples:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

A maioria das letras e caracteres vai corresponder a si mesma, como você viu no exemplo.

A função match() retorna um objeto de match se o texto corresponder ao padrão. Caso contrário, retorna None. O módulo re também contém várias outras funções — você verá algumas delas mais adiante.

Por enquanto, foque nos caracteres ordinários!

Percebeu o r no início do padrão Cookie?
Isso é um raw string literal. Ele altera como o literal de string é interpretado. Esses literais são armazenados exatamente como aparecem.

Por exemplo, \ é apenas uma barra invertida quando você usa o prefixo r, em vez de ser interpretada como sequência de escape. Você verá o que isso significa com os caracteres especiais. Às vezes, a sintaxe envolve caracteres com barra invertida, e para evitar que sejam interpretados como escapes, você usa o prefixo r.

DICA: Neste exemplo ele não é obrigatório; ainda assim, é uma boa prática usá-lo por consistência.

Caracteres coringa: caracteres especiais

Caracteres especiais não correspondem literalmente ao que você vê: têm um significado especial em expressões regulares. De forma simples, pense neles como metacaracteres reservados que representam outra coisa.

Vamos ver alguns exemplos desses caracteres em ação...

Antes disso, os exemplos abaixo usam duas funções: search() e group().
Com a função search, você percorre a string/ sequência em busca da primeira posição onde a regex gera um match.
A função group retorna a string que foi casada pela regex. Você verá ambas em mais detalhes depois.

Voltando aos caracteres especiais.

. - Um ponto. Corresponde a qualquer caractere único, exceto a quebra de linha.

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ - Circunflexo. Corresponde ao início da string.

Útil quando você quer garantir que um documento/frase comece com certos caracteres.

re.search(r'^Eat', "Eat cake!").group()

## Já o código abaixo não dará o mesmo resultado. Teste aí:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ - Corresponde ao fim da string.

Útil quando você quer garantir que um documento/frase termine com certos caracteres.

re.search(r'cake$', "Cake! Let's eat cake").group()

## A próxima busca retornará NONE, teste:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] - Corresponde a a ou b ou c.
[a-zA-Z0-9] - Corresponde a qualquer letra de (a a z), (A a Z) ou (0 a 9).

DICA: Caracteres fora de um intervalo podem ser casados complementando o conjunto. Se o primeiro caractere do conjunto for ^, todos os caracteres que não estão no conjunto serão correspondidos.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## Corresponde a qualquer caractere exceto 5
re.search(r'Number: [^5]', 'Number: 0').group()

## Este não vai casar e retornará NONE
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ - Barra invertida.
Talvez, o metacaractere mais versátil!

• Se o caractere após a barra invertida for um escape reconhecido, assume-se o significado especial do termo (Cenário 1)
• Se o caractere após \ não for um escape reconhecido, então \ é tratado como caractere comum (Cenário 2).
• \ pode ser usado antes de todos os metacaracteres para remover seu significado especial (Cenário 3).

## (Cenário 1) Trata '\s' como escape: '\s' define um espaço
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Cenário 2) '\' é tratado como caractere comum, pois '\r' não é um escape reconhecido
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Cenário 3) '\s' é escapado com uma `\` extra, sendo interpretado literalmente como '\s'
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

Há um conjunto de sequências especiais predefinidas que começam com '\' e são muito úteis em buscas e matches. Vamos ver algumas...

\w - w minúsculo. Corresponde a qualquer letra, dígito ou sublinhado.
\W - W maiúsculo. Corresponde a qualquer caractere que não faça parte de \w (w minúsculo).

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Corresponde a qualquer caractere exceto letra, dígito ou sublinhado
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## W maiúsculo não casa letra nem dígito
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - s minúsculo. Corresponde a espaço em branco: espaço, quebra de linha, tab, retorno.
\S - S maiúsculo. Corresponde a qualquer caractere que não faça parte de \s (s minúsculo).

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d - d minúsculo. Corresponde a dígitos decimais 0-9.
\D - D maiúsculo. Corresponde a qualquer caractere que não seja dígito.

# Exemplo de \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

O símbolo + usado após \d no exemplo acima indica repetição. Você verá mais disso na seção de repetições...

\t - t minúsculo. Corresponde a tab.
\n - n minúsculo. Corresponde a quebra de linha.
\r - r minúsculo. Corresponde a retorno.
\A - A maiúsculo. Corresponde apenas ao início da string. Funciona em múltiplas linhas.
\Z - Z maiúsculo. Corresponde apenas ao fim da string.
DICA: ^ e \A são praticamente equivalentes, assim como $ e \Z, exceto no modo MULTILINE. Saiba mais na seção de flags.

\b - b minúsculo. Corresponde apenas ao começo ou fim de uma palavra.

# Exemplo de \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Exemplo de \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Repetições

Buscar padrões longos em uma sequência pode ser trabalhoso. Felizmente, o módulo re lida com repetições usando os seguintes caracteres especiais:

+ - Verifica se o caractere anterior aparece uma ou mais vezes a partir daquela posição.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* - Verifica se o caractere anterior aparece zero ou mais vezes a partir daquela posição.

# Verifica qualquer ocorrência de a ou o, ou ambas, na sequência dada
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? - Verifica se o caractere anterior aparece exatamente zero ou uma vez a partir daquela posição.

# Verifica exatamente zero ou uma ocorrência de a ou o, ou ambas, na sequência dada
re.search(r'Colou?r', 'Color').group()

'Color'

Mas e se você quiser verificar um número exato de repetições?

Por exemplo, validar um número de telefone em um aplicativo. O módulo re também lida com isso muito bem usando:

{x} - Repete exatamente x vezes.
{x,} - Repete pelo menos x vezes.
{x, y} - Repete pelo menos x vezes, mas no máximo y.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

Os qualificadores + e * são considerados gulosos. Você verá o porquê adiante.

Agrupamento em expressões regulares

O recurso de grupo permite capturar partes do texto casado. Partes de um padrão de regex delimitadas por parênteses () são chamadas de grupos. Os parênteses não mudam o que a expressão casa; eles formam grupos dentro da sequência casada. Você vem usando group() nos exemplos deste tutorial. O simples match.group() sem argumentos continua sendo todo o texto casado.

Vamos entender com um exemplo simples. Imagine validar e-mails e querer checar o nome de usuário e o host. Aí você criaria grupos separados dentro do seu match.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # Texto completo casado
  print("Username:", match.group(1)) # Nome de usuário (grupo 1)
  print("Host:", match.group(2)) # Host (grupo 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Outra forma é usar colchetes angulares <> para criar grupos nomeados. Eles deixam o código mais legível. A sintaxe é: (?P<name>...). Substitua name pelo nome do grupo. Os ... representam o restante da sintaxe de match. Veja em ação com o mesmo exemplo:

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

DICA: Você pode acessar grupos nomeados por número em vez do nome. Mas, conforme a quantidade de grupos cresce, fica difícil lidar só com números. Crie o hábito de usar grupos nomeados.

Matching guloso vs. não guloso

Quando um caractere especial casa o máximo possível da sequência, dizemos que é um "match guloso". Esse é o comportamento padrão de regex, mas às vezes não é desejado:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

O padrão <.*> casou a string inteira até a segunda ocorrência de >.

Porém, se você quisesse casar apenas a primeira tag <h1>, poderia usar o qualificador não guloso *?, que casa o mínimo de texto possível.

Ao adicionar ? após o qualificador, o match passa a ser não guloso ou mínimo; isto é, o menor número de caracteres será casado. Ao rodar <.*?>, você obterá apenas <h1>.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Tabela resumo

Você já avançou bastante com expressões regulares. É muita informação e conceito novo! A tabela a seguir resume o que você viu até aqui. Não se preocupe se ainda não decorou todos os metacaracteres. Com tempo e prática, você vai entender as particularidades e quando usar cada um...

Este tutorial não aborda todas as sequências especiais do Python. Veja a referência da biblioteca padrão para a lista completa.

Você dominou o básico de regex! Ainda há mais conceitos que ajudam a criar expressões regulares poderosas para busca e match.

DICA: Embora regex sejam muito poderosas e úteis, cuidado com expressões longas e confusas, difíceis de entender e manter ao longo do tempo — por você e por outras pessoas.

Funções fornecidas por 're'

A biblioteca re no Python traz diversas funções para facilitar sua vida. Você já viu algumas, como re.search() e re.match(). Vamos ver mais...

compile(pattern, flags=0)

No Python, regex são tratadas como strings. Porém, com compile(), você pode compilar um padrão em um objeto de expressão regular. Quando precisa usar uma expressão várias vezes no mesmo programa, compilar com compile() e reutilizar o objeto costuma ser mais eficiente do que guardar a string. Isso porque versões compiladas dos padrões mais recentes passados a compile() e às funções de match no nível do módulo ficam em cache.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# Equivalente a:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Com essa função, você percorre a string em busca da primeira posição onde a regex produz um match. Retorna um objeto de match se encontrar; caso contrário, retorna None. Note que None é diferente de encontrar um match de comprimento zero em algum ponto da string.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Retorna um objeto de match se zero ou mais caracteres no começo da string casarem com o padrão. Caso contrário, retorna None.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# Sem match, pois "C" não está no início de "IceCream"
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() versus match()

match() verifica por um match apenas no início da string (por padrão), enquanto search() procura um match em qualquer lugar da string.

findall(pattern, string, flags=0)

Encontra todos os matches possíveis na sequência inteira e retorna uma lista de strings. Cada string retornada representa um match.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' é uma lista que armazena todos os matches possíveis
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Semelhante ao findall() — encontra todos os matches possíveis na sequência, mas retorna objetos de match como um iterador.

DICA: finditer() é uma ótima opção quando você quer mais informações sobre sua busca. O objeto de match retornado traz não só a sequência casada, mas também suas posições no texto original.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' é uma lista que armazena todos os matches possíveis
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() é a função de substituição. Retorna a string obtida ao substituir as ocorrências mais à esquerda e não sobrepostas do padrão na string pelo repl. Se o padrão não for encontrado, a string é retornada inalterada.

subn() é similar a sub(), mas retorna uma tupla com a nova string e o número de substituições realizadas.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Divide a string onde o padrão casar e retorna uma lista. Se o argumento opcional maxsplit for diferente de zero, no máximo maxsplit divisões serão feitas.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Retorna o índice inicial do match.
end() - Retorna o índice onde o match termina.
span() - Retorna uma tupla com as posições (início, fim) do match.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Flags de compilação

Percebeu o termo re.IGNORECASE no último exemplo? Conseguiu sacar a importância?

O comportamento de uma expressão pode ser modificado especificando uma flag. Você pode adicioná-las como argumento extra nas funções vistas aqui. Algumas das mais úteis:

IGNORECASE (I) - Permite correspondências sem diferenciar maiúsculas de minúsculas.
DOTALL (S) - Faz com que . case qualquer caractere, incluindo quebra de linha.
MULTILINE (M) - Permite que os âncoras de início (^) e fim ($) da string considerem novas linhas.
VERBOSE (X) - Permite escrever espaços em branco e comentários dentro da regex para deixá-la mais legível.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Usar a flag VERBOSE ajuda a entender regex complexas
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

DICA: Você pode combinar múltiplas flags usando OR bit a bit |.

Estudo de caso: trabalhando com expressões regulares

Agora que você viu como regex funcionam em Python com alguns exemplos, é hora de colocar a mão na massa! Neste estudo de caso, você vai aplicar tudo o que aprendeu.

Você vai trabalhar com a primeira parte de um e-book gratuito chamado "The Idiot", de Fiódor Dostoiévski, do Project Gutenberg. O romance é sobre o príncipe (Knyaz) Lev Nikolayevich Myshkin, um homem ingênuo cuja natureza boa, gentil e simples faz muitos acreditarem, erroneamente, que ele carece de inteligência e perspicácia. O título faz referência irônica a esse jovem.

Você escreverá algumas expressões regulares para percorrer o texto e concluir exercícios.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Envia uma requisição HTTP para obter o texto do Project Gutenberg
    raw = requests.get(url).text
    # Descarta os metadados do começo do livro
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Descarta o texto a partir da Parte 2 do livro
    stop = re.search(r"II", raw).start()
    # Mantém o texto relevante
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Exercício: encontre o número de ocorrências do pronome "the" no corpus. Dica: use a função len().

len(re.findall(r'the', processed_book))

302

• Exercício: tente converter toda ocorrência isolada de 'i' em 'I' no corpus. Garanta que o 'i' dentro de palavras não seja alterado:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Exercício: quantas vezes alguém foi citado ("") no corpus?

len(re.findall(r'\”', book))

0

• Exercício: quais são as palavras ligadas por '--' no corpus?
  Tente você mesmo! Fique à vontade para compartilhar sua resposta nos comentários.

Parabéns!

Você chegou ao fim deste tutorial de expressões regulares em Python! Ainda há muito mais para explorar na sua jornada de ciência de dados com Python.

Regex pode ter um papel importante na etapa de pré-processamento de dados. Confira o curso Cleaning Data in Python da DataCamp. Ele ensina maneiras de explorar melhor seus dados organizando e limpando para análise. No final, há um estudo de caso para colocar em prática o que acabou de aprender.

Dê uma olhada também no nosso tutorial de substituição de strings em Python.