Manual Simples Expressões Regulares Python

Manual Simples de
Expresses Regulares
em Python
Autor: Bismarck Gomes Souza Jnior

E-mail: bismarckjunior@outlook.com
Data: Setembro, 2012
bismarckjunior@outlook.com
Contedo
Mdulo re (Regular Expression) ..................................................................................................... 4
Verso do Python ........................................................................................................................... 4
Raw strings ..................................................................................................................................... 4
Sintaxe de ER em Python............................................................................................................... 5
Expresses mais modernas........................................................................................................ 8
Flags ............................................................................................................................................ 9
Funes do Mdulo ...................................................................................................................... 10
re.compile (pattern, flags=0) ................................................................................................. 10
re.search (pattern, string, flags=0) ........................................................................................ 10
re.match (pattern, string, flags=0) ......................................................................................... 10
re.split (pattern, string, maxsplit=0, flags=0) ......................................................................... 11
re.findall (pattern, string, flags=0) ......................................................................................... 11
re.finditer (pattern, string, flags=0) ........................................................................................ 12
re.sub (pattern, repl, string, count=0, flags=0) ...................................................................... 12
re.subn (pattern, repl, string, count=0, flags=0) .................................................................... 13
re.escape (string)................................................................................................................... 13
re.purge ( ) ............................................................................................................................. 13
Classes do Mdulo ....................................................................................................................... 14
re.RegexObject ......................................................................................................................... 14
search (string[, pos[, endpos]]).............................................................................................. 14
match (string[, pos[, endpos]])............................................................................................... 14
split (string, maxsplit=0)......................................................................................................... 14
findall (string[, pos[, endpos]]) ............................................................................................... 14
finditer (string[, pos[, endpos]]).............................................................................................. 14
sub (repl, string, count=0)...................................................................................................... 15
subn (repl, string, count=0) ................................................................................................... 15
flags ....................................................................................................................................... 15
groups .................................................................................................................................... 15
groupindex ............................................................................................................................. 15
pattern .................................................................................................................................... 15
re.MatchObject .......................................................................................................................... 16
expand (template).................................................................................................................. 16
group ([group1, ]) ............................................................................................................... 16
groups ([default]) ................................................................................................................... 16
groupdict ([default]) ................................................................................................................ 17
start ([group]) ......................................................................................................................... 17
end ([group]) .......................................................................................................................... 17
span ([group]) ........................................................................................................................ 17
pos ........................................................................................................................................ 18
endpos ................................................................................................................................... 18
2
Bismarck Gomes Souza Jnior
lastindex ................................................................................................................................. 18
lastgroup ................................................................................................................................ 18
re ........................................................................................................................................ 19
string ...................................................................................................................................... 19
Referncias ............................................................................................................................... 20
Site sugerido ............................................................................................................................. 20
Crticas e sugestes.................................................................................................................. 20
Mdulo re (Regular Expression)

Esse mdulo fornece operaes com expresses regulares (ER).
Para importar o mdulo, basta fazer:
>>> import re
Verso do Python
Todos os exemplos foram testados com Python v2.7.3.
Raw strings
As expresses regulares utilizam em algumas situaes a contra barra (\), porm para
utiliz-la precisam-se de 2 contra barras. Por exemplo, para usar o retrovisor em uma ER
deve-se escrever: \\1, o que representa \1.
A fim de eliminar essa necessidade, existe a notao de raw string no Python. Ela
considera cada caractere isoladamente. Para utiliz-la, basta prefixar r string. Assim,
enquanto r\\ contm dois caracteres (duas contra barras), a string \\ contm apenas um
(uma contra barra).
Exemplo:
>>> len(r\\)
2
>>> len(\\)
1
>>> r\\
\\\\
>>> print r\\
\\
>>> print \\
\
Sintaxe de ER em Python
Tipo Metacaractere
Apelido
Ponto
Descrio
Casa qualquer caractere, exceto "\n". (Veja a seo
Flags, p.9).
Representantes
Lista os caracteres possveis.

Dentro da lista os metacaracteres so caracteres
normais.
[]
Lista
Intervalo numrico.
Intervalo de letras.
Os intervalos seguem tabela ascii.
Lista com "[" (deve ser inserida no incio).
Lista com "-" (deve ser inserida no final).
[^ ]
Lista Negada
Lista os caracteres que no so possveis.
Quantificadores gulosos
Lista negada com "^" (deve ser inserida no final).

?
Opcional
Casa uma ou nenhuma ocorrncia do padro anterior.
Asterisco
Casa muitas ou nenhuma ocorrncia do padro

anterior.
Mais
{n, m}
Chaves
Casa uma ou mais ocorrncias do padro anterior.

Intervalo de repetio do padro anterior.
Pelo menos n
Exatamente n
Padro
.ato
12.30
<.>
[prg]ato
<[Bubi]>
12[:-.]30
1[.+*/%-]3
[0-9]
[0-36-8]
[a-f]
[A-D]
[Z-a]
[]inicio]
[final-]
[^0-9]!
[^kwy]
[^fim^]
[prg]atos?
</?[bip]>
[Hh]?um
.*!
hu*m*
h[auh]*
k+
bo+m
hu+m+
hum{1,3}
Ah!{0,2}
bo{3,}m
bo{3}m
Exemplo
Combinaes
gato, rato, pato, tato, mato, ...
12:30, 12-30, 12.30, 12 30, 12u30, ...
, , , , <7>, <>>, ...
gato, rato, pato
, , , 
12:30, 12-30, 12.30
1.3, 1+3, 1*3, 1/3, 1%3, 1-3
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
0, 1, 2, 3, 6, 7, 8
a, b, c, d, e, f
A, B, C, D
Z, [, \, ], ^, _, `, a
], i, n, i, c, i, o
f, i, n, a, l, a!, o!,?!, #!, r!, y!, <!, ...
Todos os caracteres exceto: k, w, y
Todos os caracteres exceto: f, i, m, ^
gato, pato, rato, gatos, patos, ratos
, , , , , 
Hum, hum, um
oi!,ah!, !, Ei!, humm!!, oh!, ...
h, hm, huum, hummmm, humm, ...
hahuah, hauhauau, h, hhuahhuahua
k, kk, kkk, kkkk, kkkkkkk, ...
bom, boom, boooom, ...
hum, huum, humm, huumm, ...
hum, humm, hummm
Ah, Ah!, Ah!!
booom, boooom, booooom, ...
booom
Especiais Alternadores
Captura de
Dados
ncoras
Quantificadores no gulosos
??
Opcional
Casa uma ou nenhuma ocorrncia do padro anterior.

Casa o mnimo possvel.
*?
Asterisco
Casa muitas ou nenhuma ocorrncia do padro

anterior. Casa o mnimo possvel.
+?
Mais
{n, m}?
Chaves
Circunflexo
Cifro
Casa o final da cadeia de caracteres."$" s ser

metacaractere no final do padro.
()
Grupo
Grupo de padro. Podem ser consultados

posteriormente.
\N
Retrovisor
Casa o n-simo grupo. "n" varia de 1 a 99.
Ou
Escape
Casa uma ou mais ocorrncias do padro anterior.

Casa o mnimo possvel.
Intervalo de repetio do padro anterior. Casa o
mnimo possvel.
Pelo menos n.
Casa o comeo da cadeia de caracteres. (Veja a seo
Flags, p. 9)
Casa ou o padro que precede ou o que sucede.
Transforma um metacaractere em caractere.
ba??
ba?
ba??c
<.*?>
<.*>
hu*?m*?
<.+?>
<.+>
hu+?m+?
hum{1,3}?
hum{1,3}
bom{2,}?
^[0-9]
^[^0-9]
[aos]$
^.{10,}$
^$
(rs)+
(h[au]+)+
(mal)-\1
(.(.))\1\2
hi|ap
h(ea|o)t
(m|big)-?\1
a|bc|def
a|(bc|de)f
(w{3}\.)?z\.br
[0-9]\.[0-9]+
\\
1 \+2
Casa "b" de: ba, baa, ...

Casa "ba" de: ba, baa
Casa "bac" de: bac
Casa "" de: oi
Casa "oi" de: oi
Casa "h" de: huumm, hum, ...
Casa "" de: oi
Casa "oi" de: oi
Casa "huum" de: huumm, huum, ...
Casa "hum" de: humm, hummm, ...
Casa "humm" de: humm, hummm, ...
Casa "bomm" de: bomm, bommm, ...
Textos que comeam com nmeros
Textos que no comeam com nmeros
Textos que terminam com: a, o ou s
Textos com pelo menos 10 caracteres
Textos em branco
rs, rsrs, rsrsrs, ...
haua,huahuaauu, hahuhau, ...
mal-mal
babaca, ...
hi,ap
heat,hot
mm, m-m, bigbig, big-big
a, bc, def
a, bcf, def
www.z.br, z.br
2.718, 3.14, 1.4142, ...
\
1+2
Padres Individuais
\A
Incio
Casa apenas o comeo da cadeia de caracteres.
\b
Borda
Casa as bordas das palavras. Detecta as bordas por

separao de letras.
\B
No-borda
\d
Dgito
\D
No-dgito
\s
Branco
\S
No-branco
\w
Palavra
\W
No-palavra
\Z
Fim
Negao de "\b". No casa borda
\AEra
\A[AO]
\bera
\bera\b
m\b
py\B
^\d
(\d)\1
^\D
Negao de "\d". No casa dgitos. Equivalente a [^0-9].
(\D)\1
.\s.
Casa os espaos em branco. Equivalente a [ \t\n\r\f\v].
!\s[A-D]
a\Sa
Negao de "\s". No casa espaos em branco.
Equivalente a [^ \t\n\r\f\v]
!\s\S
(\w)\1
Casa caracteres alfanumricos e "_". Equivalente a [azA-Z0-9_].
\w\d
(\W)+
Negao de "\w". Equivalente a [^a-zA-Z0-9_].
\w\W
\d\Z
Casa apenas o fim da cadeia de caracteres.
\D\Z
Casa dgitos de 0 a 9. Equivalente a [0-9].
Textos que comecem com: Era

Textos que comecem com: A ou O
Palavras que comecem com: era
Casa a palavra "era" dentro do texto
Palavras que terminem com: m
Casa o "py" de: python, py3, py4, pyQt, ...
No casa o "py" de: py!, .py, py., ...
Linhas que comeam com um dgito
00, 11, 22, 33, 44, 55, 66, 77, 88, 99
Linhas que no comeam com um dgito.
??, mm, !!, gg, pp, ...
a c, e r, 1 d, ...
! A, ! B, ! C, ! D
aba, asa, a!a, aha, ata, a#a, ...
! A, ! f, ! 3, ! =, ! y, ...
bb, cc, SS, 33, __, mm, ...
b1, b2, g5, a3, g7, v0, d6, ...
!, !@, !@#, $#, $@!?, $, ...
s!, D$, n?, o@, ...
Textos que terminem com um dgito
Textos que no terminem com um dgito
Expresses mais modernas

Padro (?...)
(?#comentario)ER
(?iLmsux)ER
(?P=id)
(?=ER)
(?!ER)
(?<=ER)
(?<!ER)
(?:ER)
Descrio
Insere um comentrio, tal que "texto" o
comentrio.
Inclui flags a partes de uma ER.
i
IGNORECASE
L LOCALE
m MULTILINE
s DOTALL
u UNICODE
x VERBOSE
Casa o que foi casa pelo grupo nomeado de
"id".
Casar o padro precedente somente se a ER
casar.
Casar o padro precedente somente se a ER
no casar.
Casar o padro posterior somente se a ER
casar.
Casar o padro posterior somente se a ER
no casar.
Grupo ignorado pelo retrovisor.
(?P<nome>ER)
Cria um nome para o grupo: "nome".
(?(id/nome)s|n)
Casa o padro "s" se o grupo "id" ou "nome"

tiver sido casado. Caso contrrio, casar o
padro "n".
Exemplo
Padro
(?#corrigir)e.tenso
Combinaes
extenso, estenso, e5tenso,...
(?imu)[a-z]{2}
(?i)[a-z]{2}
(?m)\d$
(?s).*
(?u)\w
(?x)\d #digito
(?P<inicio>.)(?P=inicio)
(?P<dia>\d\d)/(?P=dia)
Chico (?=Xavier)
meia (?=pp|gg)
Chico (?!Xavier)
meia (?!m)
(?<=meia) pp
(?i)(?<=Ford) Ka
(?<!meia )pp
(?i)(?<!Ford )Ka
(.+)-(?:a)-(\1)
(.*)-?(?:\1)
(?P<animal>[prg]ato)
(?P<nome>[Bb]runa)
(<)?(\w)(?(1)>|!)
(?P<n><)?(\w)(?(n)>|!)
(<)?(\w)(?(1)>)
Li, Na, Ka, Rb, Cs, Fr ...

Be, Mg, Ca, Sr, Ba, Ra, ...
Linhas terminando com nmero
Casa todo o texto
Casa "", "","", ...
7, 5, 3, 2, ...
uu,tt, mm, gg, pp, ...
12/12, 11/11, 04/04, ...
Casa "Chico" de: Chico Xavier
Casa "meia" de: meia pp, meia gg
Casa "Chico" de: Chico Anysio
Casa "meia" de: meia pp, meia gg
Casa "pp" de: meia pp
Casa "ka" de: ford ka
Casa "pp" de: Apple
Casa "ka" de: kaka
passo-a-passo, dia-a-dia, ...
mm, big-big, mal-mal, ...
pato, rato, gato
Bruna, bruna
, , h!, j!, g!, ...
, , h!, j!, g!, ...
b, , p, , ...
Flags
Exemplo
Padro
Combinaes
(?i)[a-c]
a, b, c, A, B, C
Casa tanto maisculas quanto
i IGNORECASE
minsculas.
(?i)[A-C]
a, b, c, A, B, C
Faz \w, \W, \b, \B, \s e \S
* No consegui alterar a localizao para testar.
L LOCALE
depender do locale (localizao.) Dizem que [a-z] casar "", "", "", ...
Linhas terminando com nmero
Faz a ncora "^" casar o incio de (?m)\d$
m MULTILINE
cada linha. J o "$", o final.
(?m)^[0-9]
Linhas iniciando com nmero
(?s).*
Casa todo o texto
Faz o metacaractere "." casar
s DOTALL
tudo, incluindo "\n".
.*
Casa cada linha do texto
Casa "", "","", ...
Faz \w, \W, \b, \B, \d, \D, \s and \S (?u)\w
u UNICODE
dependerem do padro Unicode. \w
No casa "", "", "", ...
(?x)\d
#digito
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Comentrios (#) e espaos em
x VERBOSE
branco so ignorados. O espao
(?x)\d\ \d
4 6, 5 3, 1 2, ...
deve ser precedido por "\".
(?x)\d \d
07, 22, 24, 51, 69, 71
Flags
Descrio
Funes do Mdulo
re.compile (pattern, flags=0)

pattern: padro, ER a ser casada.
flags: re.IGNORECASE (re.I), re.LOCALE (re.L), re.MULTILINE (re.M), re.DOTALL
(re.S), re.UNICODE (re.U), re.VERBOSE (re.X)
retorna: re.RegexObject
Compila o pattern.
Exemplo:
>>> import re
>>> regexobj1 = re.compile(r\w, re.I)
>>> re.compile(\\w, re.IGNORECASE)
<_sre.SRE_Pattern object at >
# ou
re.search (pattern, string, flags=0)

string: texto a ser scaneado.
retorna: re.MatchObject ou None
Procura a ocorrncia do pattern dentro da string.
Exemplo:
>>> import re
>>> re.search(r\w, 7s)
<_sre.SRE_Match object at >
re.match (pattern, string, flags=0)

string: texto a ser scaneado.
retorna: re.MatchObject ou None
Procura a ocorrncia do pattern no incio da string. Se o pattern casar o incio da string,
a funo retorna o re.MatchObject correspondente. Seno, retorna None.
Mesmo que a flag re.MULTILINE seja usada, esta funo no ir casar o comeo de
cada linha e sim o comeo da string.
Exemplo:
>>> import re
>>> re.match(r\d, a1b2c3)
>>> re.match(r.\d, a1b2c3)
<_sre.SRE_Match object at >
# Retorna None
re.split (pattern, string, maxsplit=0, flags=0)

pattern:
string:
maxsplit:
flags:
retorna:
padro, ER a ser casada.

texto a ser scaneado.
nmero mximo de pedaos.
re.IGNORECASE (re.I), re.LOCALE (re.L), re.MULTILINE (re.M),
re.DOTALL (re.S), re.UNICODE (re.U), re.VERBOSE (re.X)
lista
Fatia a string nos pontos onde o pattern casa com a string.

Quando existir grupos dentro do pattern, estes tambm sero adicionados lista.
Quando o maxsplit alcanado, adicionado o restante da string no final da lista.
Exemplo:
>>> import re
>>> re.split(rq\d, a1b2c3)
[a, b, c, ]
>>> re.split(r\d, a1b2c3[:-1])
[a, b, c]
>>> re.split(r(\d), a1b2c3)
[a, 1, b, 2, c, 3]
>>> re.split(r(\d), a1b2c3, 2)
[a, 1, b2c3]
>>> re.split(r\w, a1b2c3, 2)
[, , , , , , ]
>>> re.split(r\W, a1b2c3, 2)
[a1b2c3]
re.findall (pattern, string, flags=0)

pattern:
string:
flags:
retorna:

lista
Retorna os valores casados em forma de lista. Se no encontrar nada, retorna uma

lista vazia.
Caso exista um grupo, retornar-se- uma lista deste. Caso exista mais de um grupo,
retornar-se- uma lista de tuplas.
11
Exemplo:
>>> import re
>>> re.findall(r\d\D, a1b2c3)
[1b, 2c]
>>> re.findall(r\d(\D), a1b2c3)
[b, c]
>>> re.findall(r\d(?:\D), a1b2c3)
[1b, 2c]
>>> re.findall(r(\d)(\D), a1b2c3)
[(1, b), (2, c)]
>>> re.findall(r\d\d, a1b2c3)
[]
re.finditer (pattern, string, flags=0)

pattern:
string:
flags:
retorna:

iterador para re.MatchObject
Exemplo:
>>> import re
>>> for m in re.finditer(\d, a1b2c3):
...
print m.start(),
1 3 5
re.sub (pattern, repl, string, count=0, flags=0)

pattern:
repl:
string:
count:
flags:
retorna:

string ou funo que substituir o pattern.
nmero mximo de substiuies.
string substituida
Se repl for uma string, os escapes (\n, \r, \t, ...) sero aceitos. Alm disso, as
referncias aos grupos casados no padro tambm so aceitas. Para isso, pode-se
utilizar as expresses \N e \g<nome/id>, por exemplo: \1 ou \g<1>, \11 ou
\g<11>, \g<nome>.
Se repl for uma funo, ela ser chamada para cada ocorrncia do padro. Essa
funo deve receber um objeto do tipo re.MachObject e retornar a string a ser
substituda.
Se o pattern no for encontrado, a funo retornar a string inalterada.
12
Exemplo:
>>> import re
>>> re.sub(r\d\B, , a1b2c3, 1)
ab2c3
>>> re.sub(r(\d)\B, r\1\1, a1b2c3)
a11b22c3
>>> def funcao(matchobj):
...
if matchobj.group(0) == 1:
return
...
elif matchobj.group(0) == 2: return o
...
else: return a
...
>>> re.sub(r\d, funcao, a1b2c3)
a boca
re.subn (pattern, repl, string, count=0, flags=0)

pattern:
repl:
string:
count:
flags:
retorna:

string ou funo para substituir o pattern.
tupla com a nova string e o nmero de substituies feitas.
Exemplo:
>>> import re
>>> re.subn(r\d\B, , a1b2c3, 4)
(abc3, 2)
re.escape (string)
string:
retorna:
texto a ser transformado.

texto com \.
Exemplo:
>>> import re
>>> re.escape(\\)
\\\\
>>> re.escape(\n)
\\\n
re.purge ( )
Limpa o cache do mdulo.
13
Classes do Mdulo
re.RegexObject
Exemplo:
>>> import re
>>> regexobj = re.compile ((\d)(?P<nome>\D), re.I)
search (string[, pos[, endpos]])

string:
pos:
endpos:
retorna:
match (string[, pos[, endpos]])

string:
pos:
endpos:
retorna:

posio inicial para procura
posio final para procura
re.MatchObject ou None

posio inicial para procura
posio final para procura
re.MatchObject ou None
split (string, maxsplit=0)

string:
maxsplit: nmero mximo de pedaos.
retorna: lista
findall (string[, pos[, endpos]])

string:
pos:
endpos:
retorna:

posio inicial para procura.
posio final para procura.
lista
finditer (string[, pos[, endpos]])

string:
pos:
endpos:
retorna:

posio inicial para procura.
posio final para procura.
iterador para re.MatchObject
14
sub (repl, string, count=0)

repl:
string:
count:
retorna:

string substituida
subn (repl, string, count=0)

repl:
string:
count:
retorna:

tupla com a nova string e o nmero de substituies feitas.
o flags
Retorna um inteiro que representa uma combinao de flags utilizadas na compilao
ou no pattern.
Exemplo:
>>> regexobj.flags
0
o groups
Nmero de grupos no pattern.
Exemplo:
>>> regexobj.groups
2
o groupindex
Dicionrio com os nomes dos grupos definidos por (?P<nome>), onde a chave o
nome e o valor o nmero do grupo.
Exemplo:
>>> regexobj.groupindex
{nome: 2}
o pattern
Padro (ER) a partir do qual foi compilado.
Exemplo:
>>> regexobj.pattern
'(\\d)(?P<nome>\\D)'
15
re.MatchObject
Exemplo:
>>> import re
>>> matchobj1
>>> matchobj2
>>> matchobj3
>>> matchobj4
=
=
=
=
re.match(r(..), a1b2c3)
#casa 1 vez
re.match(r(..)+, a1b2c3) #casa 3 vezes
re.search(r(..)(?P<dp>\d\D), a1b2c3)
re.match(r(?P<g1>\d\D)(?P<g2>\D\d)?, a1b2c3)
expand (template)
template: modelo
retorna: string
Retorna a string obtida pela substituio das contra barras. O template pode utilizar as
expresses como \N e \g<nome/id>, alm dos escapes.
Exemplo:
>>> matchobj1.expand(rcasa: \1)
casa: a1
>>> matchobj2.expand(rcasa: \g<1>)
casa: c3
group ([group1, ])
[group1, ]: id ou nome do grupo.
retorna:
retorna um ou mais subgrupos ou None
O nmero default 0, o qual retorna toda string casada. Retorna None quando o grupo
no casa nada.
Exemplo:
>>> matchobj3.group( )
1b2c
>>> matchobj3.group(0)
1b2c
>>> matchobj3.group(1)
1b
>>> matchobj3.group(dp)
2c
>>> matchobj3.group(1, 2)
(1b, 2c)
groups ([default])
[default]:
retorna:
valor a ser retornado quando um grupo no for casado.

tupla com os grupos casados.
Quando o grupo no for casado, ele retorna None, a menos que o default seja
indicado.
16
Exemplo:
>>> matchobj3.groups()
(1b, 2c)
>>> matchobj4.groups()
(a1, None)
>>> matchobj4.groups(vazio)
(a1, vazio)
groupdict ([default])
[default]:
retorna:
valor a ser retornado quando um grupo no for casado.

dicionrio tal que as chaves so os nomes dos grupos.
Exemplo:
>>> match4.groupdict( )
{'g2': None, 'g1': 'a1'}
>>> match4.groupdict(vazio)
{'g2': vazio, 'g1': 'a1'}
start ([group])
[group]:
retorna:
id ou nome do grupo.
posio inicial do grupo na string recebida.
Exemplo:
>>> matchobj3.start()
1
>>> matchobj4.start(g1)
0
>>> matchobj4.start(g2)
-1
end ([group])
[group]:
retorna:
id ou nome do grupo casado.

posio final do grupo na string recebida.
Exemplo:
>>> matchobj3.end()
5
>>> matchobj4.end(g1)
2
>>> matchobj4.end(g2)
-1
span ([group])
[group]:
retorna:
id ou nome do grupo.
tupla com a posio inicial e final do grupo na string recebida.
17
Exemplo:
>>> matchobj3.span()
(1, 5)
>>> matchobj4.span(g1)
(0, 2)
>>> matchobj4.span(g2)
(-1, -1)
o pos
Posio inicial para procura na string passada. Veja os mtodos search( ) e match( )
da classe re.RegexObject.
Exemplo:
>>> m1.pos
0
o endpos
Posio final para procura na string passada. Veja os mtodos search( ) e match( )
da classe re.RegexObject.
Exemplo:
>>> m1.endpos
6
o lastindex
ndice do ltimo grupo capturado. Retorna None se nenhum grupo for capturado.
Exemplo:
>>> matchobj1.lastindex
1
2
1
o lastgroup
Nome do ltimo grupo capturado. Retorna None se nenhum grupo for capturado.
Exemplo:
>>> matchobj1.lastgroup
dp
g1
18
o re
O objeto da classe re.RegexObject que representa a expresso regular que gerou a
classe.
Exemplo:
>>> matchobj1.re.pattern
(..)
>>> matchobj4.re.pattern
'(?P<g1>\\D\\d)(?P<g2>\\d\\D)?'
o string
Retorna a string da classe.
Exemplo:
>>> matchobj1.string
a1b2c3
>>> matchobj4.string
a1b2c3
19
Referncias
[1] http://www.diveintopython.net/regular_expressions/index.html
[2] http://docs.python.org/library/re.html
[3] http://pt.wikipedia.org/wiki/Express%C3%A3o_regular
[4] http://en.wikipedia.org/wiki/Regular_expression
[5] http://aurelio.net/regex/guia/
[6] http://linux.studenti.polito.it/elda/elda/GNUtemberg/python/regex.pdf
[*] Todos os acessos em agosto de 2012
Site sugerido
http://www.pythonregex.com/
Crticas e sugestes
20

Manual Simples Expressões Regulares Python

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual Simples Expressões Regulares Python

Uploaded by

Copyright:

Available Formats

Manual Simples de

Autor: Bismarck Gomes Souza Jnior

Bismarck Gomes Souza Jnior

Mdulo re (Regular Expression)

Bismarck Gomes Souza Jnior

Lista os caracteres possveis.

Lista os caracteres que no so possveis.

Lista negada com "^" (deve ser inserida no final).

Casa uma ou nenhuma ocorrncia do padro anterior.

Casa muitas ou nenhuma ocorrncia do padro

Casa uma ou mais ocorrncias do padro anterior.

Casa uma ou nenhuma ocorrncia do padro anterior.

Casa muitas ou nenhuma ocorrncia do padro

Casa o final da cadeia de caracteres."$" s ser

Grupo de padro. Podem ser consultados

Casa o n-simo grupo. "n" varia de 1 a 99.

Casa uma ou mais ocorrncias do padro anterior.

Casa ou o padro que precede ou o que sucede.

Transforma um metacaractere em caractere.

Casa "b" de: ba, baa, ...

Bismarck Gomes Souza Jnior

Casa apenas o comeo da cadeia de caracteres.

Casa as bordas das palavras. Detecta as bordas por

Negao de "\b". No casa borda

Textos que comecem com: Era

Expresses mais modernas

Cria um nome para o grupo: "nome".

Casa o padro "s" se o grupo "id" ou "nome"

Li, Na, Ka, Rb, Cs, Fr ...

Bismarck Gomes Souza Jnior

Bismarck Gomes Souza Jnior

re.compile (pattern, flags=0)

re.search (pattern, string, flags=0)

re.match (pattern, string, flags=0)

Bismarck Gomes Souza Jnior

re.split (pattern, string, maxsplit=0, flags=0)

padro, ER a ser casada.

Fatia a string nos pontos onde o pattern casa com a string.

re.findall (pattern, string, flags=0)

padro, ER a ser casada.

Retorna os valores casados em forma de lista. Se no encontrar nada, retorna uma

re.finditer (pattern, string, flags=0)

padro, ER a ser casada.

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

padro, ER a ser casada.

Bismarck Gomes Souza Jnior

re.subn (pattern, repl, string, count=0, flags=0)

padro, ER a ser casada.

texto a ser transformado.

search (string[, pos[, endpos]])

match (string[, pos[, endpos]])

texto a ser scaneado.

texto a ser scaneado.

split (string, maxsplit=0)

findall (string[, pos[, endpos]])

texto a ser scaneado.

finditer (string[, pos[, endpos]])

texto a ser scaneado.

Bismarck Gomes Souza Jnior

sub (repl, string, count=0)

string ou funo para substituir o pattern.

subn (repl, string, count=0)

string ou funo para substituir o pattern.

valor a ser retornado quando um grupo no for casado.