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
bismarckjunior@outlook.com
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 \\
\
Bismarck Gomes Souza Jnior
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, ...
<b>, <i>, <u>, <p>, <7>, <>>, ...
gato, rato, pato
<B>, <u>, <b>, <i>
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
<b>, </b>, <i>, </i>, <p>, </p>
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
bismarckjunior@outlook.com
??
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 "<b>" de: <b>oi</b>
Casa "<b>oi</b>" de: <b>oi</b>
Casa "h" de: huumm, hum, ...
Casa "<b>" de: <b>oi</b>
Casa "<b>oi</b>" de: <b>oi</b>
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
Bismarck Gomes Souza Jnior
\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
bismarckjunior@outlook.com
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
<b>, <p>, h!, j!, g!, ...
<b>, <p>, h!, j!, g!, ...
b, <b>, p, <p>, ...
Bismarck Gomes Souza Jnior
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
Bismarck Gomes Souza Jnior
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)
pattern: padro, ER a ser casada.
string: texto a ser scaneado.
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.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)
pattern: padro, ER a ser casada.
string: texto a ser scaneado.
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.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.
Bismarck Gomes Souza Jnior
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:
padro, ER a ser casada.
texto a ser scaneado.
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
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
bismarckjunior@outlook.com
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:
padro, ER a ser casada.
texto a ser scaneado.
re.IGNORECASE (re.I), re.LOCALE (re.L), re.MULTILINE (re.M),
re.DOTALL (re.S), re.UNICODE (re.U), re.VERBOSE (re.X)
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:
padro, ER a ser casada.
string ou funo que substituir o pattern.
texto a ser scaneado.
nmero mximo de substiuies.
re.IGNORECASE (re.I), re.LOCALE (re.L), re.MULTILINE (re.M),
re.DOTALL (re.S), re.UNICODE (re.U), re.VERBOSE (re.X)
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
Bismarck Gomes Souza Jnior
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:
padro, ER a ser casada.
string ou funo para substituir o pattern.
texto a ser scaneado.
nmero mximo de substiuies.
re.IGNORECASE (re.I), re.LOCALE (re.L), re.MULTILINE (re.M),
re.DOTALL (re.S), re.UNICODE (re.U), re.VERBOSE (re.X)
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
bismarckjunior@outlook.com
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:
texto a ser scaneado.
posio inicial para procura
posio final para procura
re.MatchObject ou None
texto a ser scaneado.
posio inicial para procura
posio final para procura
re.MatchObject ou None
split (string, maxsplit=0)
string:
texto a ser scaneado.
maxsplit: nmero mximo de pedaos.
retorna: lista
findall (string[, pos[, endpos]])
string:
pos:
endpos:
retorna:
texto a ser scaneado.
posio inicial para procura.
posio final para procura.
lista
finditer (string[, pos[, endpos]])
string:
pos:
endpos:
retorna:
texto a ser scaneado.
posio inicial para procura.
posio final para procura.
iterador para re.MatchObject
14
Bismarck Gomes Souza Jnior
sub (repl, string, count=0)
repl:
string:
count:
retorna:
string ou funo para substituir o pattern.
texto a ser scaneado.
nmero mximo de substiuies.
string substituida
subn (repl, string, count=0)
repl:
string:
count:
retorna:
string ou funo para substituir o pattern.
texto a ser scaneado.
nmero mximo de substiuies.
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
bismarckjunior@outlook.com
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
Bismarck Gomes Souza Jnior
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
bismarckjunior@outlook.com
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
>>> matchobj3.lastindex
2
>>> matchobj4.lastindex
1
o lastgroup
Nome do ltimo grupo capturado. Retorna None se nenhum grupo for capturado.
Exemplo:
>>> matchobj1.lastgroup
>>> matchobj3.lastgroup
dp
>>> matchobj4.lastgroup
g1
18
Bismarck Gomes Souza Jnior
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
bismarckjunior@outlook.com
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
bismarckjunior@outlook.com
20
