Tutorial de Expressão Python Regular

  1. Expressão Regular Python re.match() Função
  2. Expressão regular Python re.search() função
  3. Compilando expressões regulares com re.complie
  4. Bandeiras no módulo de expressão regular Python re
  5. Verificação de caracteres permitidos
  6. Pesquisar e substituir
  7. A função findall()
  8. A função finditer()
  9. A função split()função
  10. Padrões básicos de re
  11. Casos de repetição
  12. Repetição não desejada
  13. Caracteres e seqüências especiais em re
  14. A função escape
  15. A função group()

Neste tutorial, você aprenderá as Expressões Regulares e as operações de expressão regular definidas no módulo re em Python. O re é a biblioteca padrão do Python que suporta operações de correspondência de expressão regular.

Expressão regular em Python é um array de caracteres ou sequência que é utilizado para fazer corresponder uma string a outro padrão utilizando uma sintaxe formal. Você poderia pensar em expressões regulares como uma pequena linguagem de programação que está embutida em python.

Você pode usar expressões regulares para definir algumas regras e estas regras são então usadas para criar possíveis strings a partir da string dada com a qual você quer combinar o padrão. Expressões regulares em Python são interpretadas como um array de instruções.

Expressão Regular Python re.match() Função

Você pode usar a função de correspondência para combinar o padrão RE com a string dada. A função de correspondência contém bandeiras. As bandeiras definem o comportamento de uma expressão regular e podem conter valores diferentes que você verá mais tarde neste tutorial.

O seguinte é a sintaxe da função de correspondência em Python:

re.match(pattern, string, flags)

Ela tem três argumentos,

  1. pattern é o padrão de expressão regular que deve ser correspondido
  2. string é a string dada que deve ser combinada com a expressão regular
  3. flags é utilizado para mudar o comportamento da expressão regular, e é opcional.

Se a correspondência for realizada com sucesso, o objeto match será devolvido, caso contrário, o objeto None será devolvido. O objeto match tem mais dois métodos principais que são funções group(num) e group(). O objetivo principal para utilizar estas funções é retornar a correspondência ou uma subsequence específica e todas as subsequences, respectivamente.

Utilizando a função re.match

O exemplo a seguir demonstra como você pode utilizar a função match:

import re
strTest = "Hello Python Programming"
mobj = re.match(r"hello", strTest, re.I)
print(mobj.group())

Neste código, primeiro de tudo o módulo re é importado. Então você irá comparar uma string strTest com o padrão RE e o valor retornado da função de comparação será atribuído ao mobj. A função de comparação é chamada utilizando re, então dentro de parênteses o primeiro argumento é o padrão a ser comparado, e então você terá a string dada a partir da qual o padrão será comparado e também um valor de flag é passado. Aqui re.I é o valor de flag que significa IGNORECASE, então será ignorado se o padrão e a string têm letras maiúsculas ou minúsculas diferentes.

A saída é :

Hello

Neste exemplo, o prefixo r é utilizado, o que diz que a string é uma string bruta. Em uma string bruta não há necessidade de escrever barras duplas ao utilizar seqüências de escape, por exemplo, se você quiser uma barra invertida, então você só tem uma única \, mas não barras invertidas duplas \\ como você tinha em strings normais. Esta é a única diferença entre uma string normal e uma string bruta.

Utilizando a função re.match com string normal

Considere o exemplo abaixo no qual uma string normal é usada em vez de uma string bruta:

import re
str = "\\tHello Python Programming"
mobj = re.match("\\thello", str, re.I) #no match

str = "\tHello Python Programming"
mobj = re.match("\\thello", str, re.I) #\thello is matching

Expressão regular Python re.search() função

Você pode utilizar a função re.search() para pesquisar o padrão RE na string dada. A função search contém três argumentos na função o pattern, dado string, e flags (opcional), respectivamente.

O seguinte é a sintaxe da função de busca em Python:

re.search(pattern, string, flags)

O seguinte código Python demonstra a utilização da função search():

import re
str = "Hello Python Programming"
sobj = re.search(r"programming", str, re.I)
print(sobj.group())
Programming

Neste código a busca pela palavra programming está sendo feita. A função search procura em toda a string. A diferença entre busca e correspondência é que a função match só verifica no início da string, enquanto a função search busca em toda a string.

Se você quiser pesquisar no início da string, então você pode usar ^. Considere o seguinte exemplo:

import re
str = "Hello Python Programming"
sobj = re.search(r"^programming", str, re.I)
print(sobj.group()) #no match is found

sobj = re.search(r"^hello", str, re.I)
print(sobj.group()) #matching: Hello

Aqui ^ fará a busca apenas no início da string.

Você também pode pesquisar no final da string dada. Pode ser feito utilizando $ no final do padrão. Considere o código abaixo:

import re
str = "Hello Python Programming"
sobj = re.search(r"programming$", str, re.I)
print(sobj.group()) #matching: Programming

sobj = re.search(r"hello$", str, re.I)
print(sobj.group()) #no match found

Compilando expressões regulares com re.complie

Expressões regulares em Python quando compiladas são convertidas em padrões. Esses padrões são na verdade os objetos padrão que contêm diferentes funções para executar diferentes tarefas que podem incluir pesquisa, correspondência, e substituição, etc.

Quando você compila um padrão, então você pode usar esse padrão mais tarde no programa.

Usando padrões pré-compilados

Considere o código abaixo no qual o padrão r"\d" é compilado, que significa o primeiro dígito na string e depois utilizou este padrão para chamar a função de busca e passou uma string na função de busca. Este padrão será pesquisado na string fornecida para a função de pesquisa. Da mesma forma, você pode utilizar este padrão pré-compilado com função de correspondência, como a seguir:

import re
compPat = re.compile(r"(\d)")
sobj = compPat.search("Lalalala 123")
print(mobj.group())

mobj = compPat.match("234Lalalala 123456789")
print(mobj.group())
1
2

Bandeiras no módulo de expressão regular Python re

Você pode usar Bandeiras são para mudar o comportamento de uma expressão regular. Em uma função, as bandeiras são opcionais. É possível utilizar as flags de duas maneiras diferentes, ou utilizando a palavra-chave flags e atribuindo-lhe valor de marcação ou escrevendo diretamente o valor da marcação. Você pode ter mais de um valor de flag no literal RE; isto pode ser feito utilizando o operador OR bit a bit |.

Considere a seguinte tabela na qual algumas das bandeiras comumente utilizadas são descritas com expressões literais regulares:

Valor da Bandeira Descrição
re.I Este modificador irá ignorar o caso de strings e padrões durante a correspondência.
re.L Este modificador é utilizado para interpretar palavras com respeito ao locale atual.
re.M Este modificador é utilizado para fazer $ para combinar com o fim da linha e não com o fim da string. Da mesma forma, ^ irá combinar no início da linha ao invés de no início da string.
re.S Este modificador é utilizado para fazer um ponto . para combinar com qualquer caractere. Isto inclui uma nova linha também.
re.U Este modificador é utilizado para interpretar os caracteres como um array de caracteres Unicode.
re.X Ele é utilizado para ignorar os espaços em branco. Ele irá fazer # como um marcador de comentário.

Utilizando múltiplos valores de flag

Considere o seguinte código Python no qual você verá como usar múltiplos valores de bandeira para mudar o comportamento do RE. Valores de flag múltiplos podem ser incluídos pelo operador bitwise OR (|):

import re
s = re.search("L", "Hello")
print(s)		#Output: None, L is there but in small letter and we didn't use flags

s = re.search("L", "Hello", re.I)
print(s)		#Output: 1

s = re.search("L", "^Hello", re.I | re.M)
print(s)		#Output: 1, searching will be made from the start of line and case is ignored

Verificação de caracteres permitidos

Você também pode verificar se uma determinada string contém ou não algum intervalo específico de caracteres.

Definição de uma função e verificação dos caracteres permitidos

Considere o seguinte exemplo, no qual uma função é definida e também utilizada como padrão pré-compilado para verificar se os caracteres certos estão ou não na string passada:

import re
def check(str):
	s = re.compile(r'[^A-Z]')
	str = s.search(str)
	return not bool(str)
print(check("HELLOPYTHON"))		#Output: True
print(check("hellopython"))		#Output: False

Nesta função, um padrão que é r '[^A-Z]' é compilado e utilizado para pesquisar em uma string passada quando esta função chamada check é chamada. Esta função realmente verifica se a string passada contém as letras A-Z(maiúsculas) ou não. Similarmente, pode ser visto que quando você passa uma string em letras minúsculas falsas é retornada.

Pesquisar e substituir

O módulo re fornece uma função que é a função sub que é utilizada para substituir todas as ocorrências do padrão no string dado, utilizando o atributo repl na função. Os caracteres serão substituídos até que o número count seja alcançado. A função sub irá retornar a string atualizada.

O seguinte é a sintaxe da subfunção:

re.sub(pattern, repl, string, count = 0)

Utilizando a função sub

Considere o exemplo abaixo no qual a função sub substitui a string inteira por uma determinada string:

import re
s = "Playing 4 hours a day"
obj = re.sub(r'^.*$',"Working",s)
print(obj)
Working

Aqui, a função sub é utilizada. O padrão r'^.*$' significa começar do início da string e então .* significa o que quer que esteja na string até o final $ da string. Então o argumento "Working" irá substituir toda a string s.

Utilizando a função sub para apagar todos os dígitos de uma string

Considere o seguinte exemplo no qual a função sub apaga os dígitos da string dada. Para este propósito, você pode utilizar \d:

import re
s = "768 Working 2343 789 five 234 656 hours 324 4646 a 345 day"
obj = re.sub(r'\d',"",s)
print(obj)
Working   five   hours   a  day

Da mesma forma, você pode apagar os caracteres da string. Para este propósito, você pode utilizar \D.

import re
s = "768 Working 2343 789 five 234 656 hours 324 4646 a 345 day"
obj = re.sub(r'\D',"",s)
print(obj)
76823437892346563244646345

A função findall()

A função findall retorna uma lista de todas as strings que combinam com o padrão. A diferença entre a função search e findall é que a função findall encontra todas as correspondências enquanto que a função search encontra apenas a primeira correspondência. Esta função encontra as correspondências não sobrepostas e as retorna como uma lista de strings.

O seguinte é a sintaxe da função findall:

findall(pattern, string, flags)

Aqui pattern é o padrão RE que você encontrará em determinadas string com alguns valores de flags por exemplo re.I para ignorar o caso.

Encontre todas as combinações não sobrepostas

No exemplo a seguir, findall encontra jogos não sobrepostos:

import re
str = "Working 6 hours a day. Studying 4 hours a day."
mobj = re.findall(r'[0-9]', str)
print(mobj)
['6', '4']

r'[0-9]' é um padrão que encontra todos os dígitos da corda dada e é devolvida uma lista de cordas (independentemente de serem dígitos) que é armazenada em mobj.

findall com arquivos

Você também pode utilizar o findall para encontrar em um arquivo. Quando você utiliza o findall com um arquivo, ele retornará uma lista de todas as strings correspondentes no arquivo. Como a função read() do arquivo será utilizada para que você não tenha que iterar através de cada linha do arquivo utilizando um laço, pois ele retorna todo o texto do arquivo como uma string. Considere o seguinte exemplo:

import re
file = open('asd.txt', 'r')
mobj = re.findall(r'arg.', file.read())
print(mobj)
file.close()
['arg,', 'arg,', 'arg,', 'argv', 'argv', 'argv']

Neste exemplo, o arquivo é aberto primeiro no modo de leitura. O padrão r arg.`` é igualado com o conteúdo do arquivo e você tem a lista de strings correspondentes na saída.

A função finditer()

A função finditer pode ser utilizada para encontrar o padrão RE nas strings juntamente com a localização das strings correspondentes, que é o índice das strings. Esta função realmente iteratiza através das strings correspondentes e retorna os índices ou locais da string.

O seguinte é a sintaxe da função finditer:

finditer(pattern, string, flags)

Iteração sobre correspondências

A única diferença entre findall e finditer é que o finditer retorna o índice também junto com as strings correspondentes. No código abaixo, o finditer é utilizado para encontrar as localizações das strings correspondentes enquanto itera sobre correspondências (strings correspondentes) utilizando para loop.

import re
str = "Working 6 hours a day. Studying 4 hours a day."
pat = r'[0-9]'
for mobj in re.finditer(pat, str):
    s = mobj.start()
    e = mobj.end()
    g = mobj.group()
    print('{} found at location [{},{}]'.format(g, s, e))
6 found at location [8,9]
4 found at location [32,33]

Neste exemplo, o padrão são os dígitos de 0 a 9 a serem encontrados em str. Para iteração de laço sobre as strings correspondentes retornadas por finditer. No laço, as funções start, end e group retornam o índice inicial, índice final e match encontrado respectivamente em cada iteração da string retornada pelo finditer.

A função split()função

A função split é utilizada para dividir uma string.

A seguir está a sintaxe da função de divisão:

split(patter, string, maxsplit, flags)

Aqui max é o número total de partições de string. Se no máximo ocorrerem divisões maxsplit, o restante da string é retornado como o elemento final da lista. O valor padrão de máximo é 0, o que significa divisões ilimitadas.

Dividindo uma string

A função split retorna cada palavra em uma string

No código abaixo, uma string é dividida de acordo com o padrão dado e o número de divisões máximas.

import re
str = "Birds fly high in the sky for ever"
mobj = re.split('\s+', str, 5)
print(mobj)
['Birds', 'fly', 'high', 'in', 'the', 'sky for ever']

Neste exemplo, o caractere padrão \s é um caractere especial que combina com o caractere branco, que é equivalente a [ \t\n\r\f\v]. Portanto, você poderia ter palavras separadas. O valor de máximo é 5 aqui, o que faz divisão de 6, e o último elemento é o resto da string após a 5ª divisão.

Padrões básicos de re

As expressões regulares podem especificar padrões que são comparados com determinadas strings. A seguir estão os Padrões básicos de expressão regular:

Padrão Descrição
^ É usado para combinar no início da string.
$ Este padrão vai coincidir no final da string.
. Dot é utilizado para combinar com um caractere (nova linha não está incluída).
[...] É utilizado para corresponder a um único caractere dentro de parênteses.
[^...] Isto irá corresponder a um único caractere, mas não entre parênteses.
* 0 ou mais ocorrências de re precedente em determinada string.
+ 1 ou mais ocorrências de re precedente em determinada string.
? 0 ou 1 ocorrências de re precedente em determinada string.
{n} Ele irá corresponder a n número de ocorrências em determinada string.
{n,} Ele irá corresponder a n ou mais do que n número de ocorrências.
{n,m} Este padrão é usado para combinar pelo menos n e no máximo m correspondências na string.
`a b`
(re) Este padrão é usado para agrupar as expressões regulares e irá lembrar o texto correspondente.
(?imx) Ele irá alternar temporariamente em i ou m ou x em RE. Ao usar parênteses, então apenas a área de parênteses é afetada.
(?-imx) Ele irá alternar temporariamente i ou m ou x em RE. Ao usar parênteses, então apenas a área de parênteses é afetada.
(?: re) Este padrão é usado para agrupar as expressões regulares, mas não se lembrará do texto correspondente.
(?imx: re) Ele irá alternar temporariamente em i ou m ou x em RE dentro de parênteses.
(?-imx: re) Ele irá alternar temporariamente i ou m ou x em RE dentro de parênteses.
(?#...) É um comentário.
(?= re) Ele é usado para especificar a posição usando um padrão. Não tem qualquer alcance.
(?! re) Ele é usado para especificar a posição usando uma negação de padrão. Não tem nenhum alcance.
(?> re) Este padrão é usado para corresponder a um padrão independente.
\w Este padrão é usado para combinar palavras.
\W Este padrão é usado para combinar com palavras que não são palavras.
\s Vai combinar com os espaços em branco. \é igual a [ \t\n\r\f].
\S Vai combinar com os espaços não-históricos.
\d igual a [0-9]. Corresponde aos dígitos da string.
\D Corresponde a não-dígitos.
\A coincidir com o início da string.
\Z Fim da linha de jogo. E se houver alguma nova linha, ela vai coincidir antes da nova linha.
\G ao ponto em que a última partida foi terminada.
\b corresponder aos limites das palavras quando está fora dos parênteses mas quando está dentro dos parênteses corresponderá ao backspace.
\B coincidir com os limites de não palavras.
\n, \t, etc. \n é usado para combinar novas linhas, \n combina com a tabulação e assim por diante.
\1...\9 Este padrão irá corresponder à n-ésima subexpressão (agrupada).
\10 \10 normalmente corresponde à n-ésima subexpressão (agrupada) se a partida já tiver sido feita. Se a correspondência ainda não tiver sido feita, 10 irá fornecer uma representação octal de um código de caracteres.

Casos de repetição

A tabela seguinte demonstra alguns exemplos de casos de repetição com descrição:

Exemplos Descrições
ab? Vai corresponder a a ou ab.
ab* ab* será igual a ab e a’s e qualquer a’s seguido de qualquer b’s.
ab+ ab+ significa a’s seguido de b’s e não apenas a. a deve ser seguido de non zero b.
\d{2} Vai corresponder exactamente a 2 dígitos.
\d{2,} Vai corresponder a 2 ou mais dígitos.
\d{2,4} Vai coincidir com os dígitos 2, 3 e 4.

Repetição não desejada

Em expressões regulares, a repetição é por defeito gananciosa, que tenta igualar o máximo de repetições possível.

Os qualificadores como *, + e ? são qualificadores gananciosos. Quando você utiliza .*, ele realizará uma partida gananciosa e irá corresponder a toda a string, resultando na correspondência do maior número possível de caracteres. Considere o código abaixo:

import re
mobj = re.match(r'.*', "Birds fly high in sky")
print(mobj.group())
Birds fly high in the sky

Então você pode ver aqui a string inteira é igualada.

Quando você adiciona ? com .+ você terá um re não ganancioso e o padrão .+? irá coincidir com o menor número possível de caracteres na string.

import re
mobj = re.match(r'.*', "Birds fly high in sky")
print(mobj.group())

O resultado é o primeiro caracter da string

B

Caracteres e seqüências especiais em re

Os caracteres especiais em re começam com um \. Por exemplo, temos \A que vai coincidir desde o início da string.

Estes caracteres especiais estão descritos na tabela acima.

Nesta seção, você verá os exemplos de alguns dos caracteres especiais:

import re
str = "Birds fly high in the sky"
# \A
mobj = re.match(r'\Ab', str, re.I) #OUTPUT: B, here \A will match at beginning only.

#\d
mobj = re.match(r'\d', "4 birds are flying") #OUTPUT: 4

#\s
mobj = re.split('\s+', "birds fly high in the sky", 1) #OUTPUT: ['Birds', 'fly']

A função escape

A função escape é utilizada para escapar de todos os caracteres da string. As letras ASCII, números, e _ não escaparão. A função escape é utilizada quando você quer extrair metacaracteres de uma string.

A seguir está a sintaxe da função escape:

escape(pattern)

No exemplo a seguir, uma string www.python.com é passada para escapar da função escape. Neste exemplo temos . que é um metacaracter e será extraído ou combinado:

print(re.escape('www.python.com'))
www\.python\.com

Aqui . é um meta-caractere que é extraído ou igualado. Sempre que um meta-caractere for combinado utilizando a função escape, você terá \ antes do caractere.

Fugindo de caracteres especiais

Os caracteres como colchetes [ e ] não podem ser combinados. Considere o seguinte exemplo:

import re
mobj = re.search(r'[a]', '[a]b')
print(mobj.group())
a

Aqui você pode ver que os parênteses [ e ] não são combinados.

Você pode combiná-los utilizando a função escape:

import re
mobj = re.search(r'\[a\]', '[a]b')
print(mobj.group())
[a]b

A função group()

A função group é utilizada para retornar um ou mais subgrupos da partida encontrada. A função group pode ter alguns argumentos.

O seguinte é a sintaxe da função de grupo:

group(group1, group2,..., groupN)

Se você tiver um único argumento na função de grupo, o resultado será uma única string mas quando você tiver mais de um argumento, então o resultado será um tuple (contendo um item por argumento).

Quando não houver nenhum argumento, por padrão, o argumento será zero e retornará toda a partida.

Quando o argumento groupN é zero, o valor de retorno será toda a string correspondente.

Quando você especifica o número do grupo ou argumento como um valor negativo ou um valor maior que o número de grupos no padrão, então a exceção IndexError ocorrerá.

Considere o código abaixo no qual não há nenhum argumento na função group que é equivalente a group(0).

import re
str = "Working 6 hours a day"
mobj = re.match(r'^.*', str)
print(mobj.group())
Working 6 hours a day

Aqui grupo() é utilizado e você tem toda a string correspondente.

Escolhendo partes de textos correspondentes

No exemplo a seguir, a função group é utilizada com argumentos para pegar os grupos correspondentes:

import re
a = re.compile('(p(q)r)s')
b = a.match('pqrs')
print(b.group(0))
print(b.group(1))
print(b.group(2))
pqrs
pqr
q

Aqui group(0) retorna a correspondência inteira. O group(1) retorna a primeira partida que é pqr e o group(2) retorna a segunda partida que é q.

Grupos nomeados

Usando grupos nomeados, você pode criar um grupo de captura. Este grupo pode ser referido pelo nome, então. Considere o exemplo abaixo:

import re
mobj = re.search(r'Hi (?P<name>\w+)', 'Hi Roger')
print(mobj.group('name'))
Roger

Grupos não-capturadores

Grupo não-capturador pode ser criado utilizando ?:. O grupo não-capturador é utilizado quando você não quer o conteúdo do grupo.

import re
mobj = re.match("(?:[pqr])+", "pqr")
print(mobj.groups())
()