Você está na página 1de 20

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