1. O documento introduz os conceitos fundamentais de expressões regulares, incluindo alfabeto, cadeia de caracteres, concatenação e linguagens. 2. Apresenta os conceitos teóricos básicos de expressões regulares, como operações de união, concatenação e estrela. 3. Explica como aplicar expressões regulares na prática usando caracteres especiais e operadores em ferramentas como egrep e no Python.

2. UNIVERSIDADE ESTADUAL DA PARAÍBA
CENTRO DE CIÊNCIAS EXATAS E SOCIAIS APLICADAS – CAMPUS VII
CURSO DE LICENCIATURA EM COMPUTAÇÃO
PRODUÇÃO DE MATERIAIS INSTRUCIONAIS
Docente: Vítor Abílio Sobral
Discentes: Luiz Augusto de Macedo Morais e Rivanilson da Silva Rodrigues
Introdução a Expressões Regulares
2012

3. Sumário
1 Pré­requisitos....................................................................................1
Introdução..................................................................................................2
Breve História das Expressões Regulares....................................................2
Pré­requisitos .............................................................................................2
Alfabeto..................................................................................................2
Cadeia de caractere.................................................................................3
Tamanho.................................................................................................3
Sub­cadeia..............................................................................................3
Concatenação..........................................................................................4
Linguagem..............................................................................................4
Conceitos básicos sobre Expressões Regulares............................................4
2 Conceitos teóricos.............................................................................7
Definição formal de uma expressão regular ...............................................8
Operações com Expressões Regulares.........................................................9
União......................................................................................................9
Concatenação..........................................................................................9
Estrela...................................................................................................11
Precedência de operadores em expressões regulares............................12
Algumas definições importantes...........................................................12
Exemplos...............................................................................................12
3 Da teoria para a prática..................................................................14
Caracteres especiais..................................................................................15
Ponto (.)................................................................................................15
Começo da string (^)...........................................................................15
Fim da string ($)...................................................................................15
Operadores básicos...................................................................................15
União (|)...............................................................................................15

4. Estrela (*).............................................................................................16
Um ou mais (+)....................................................................................16
Zero ou um (?)......................................................................................16
Mais operadores........................................................................................17
Repetições finitas..................................................................................17
Conjuntos..............................................................................................17
Grupos..................................................................................................17
4 Praticando com expressões regulares..............................................18
CEP...........................................................................................................19
E­mail.......................................................................................................19
Primeira versão.....................................................................................19
Segunda versão.....................................................................................20
5 Ferramentas....................................................................................22
Testando ERs na Web................................................................................24
RegexPal (http://regexpal.com/)..........................................................24
RegExr (http://gskinner.com/RegExr/)................................................25
A ferramenta egrep...................................................................................25
Flags......................................................................................................26
Começo e fim de ERs............................................................................27
6 Expressões regulares com Python...................................................28
A linguagem Python..................................................................................29
Aprendendo o módulo re..........................................................................29
match....................................................................................................29
search....................................................................................................30
findall....................................................................................................31
sub........................................................................................................31
Considerações Finais............................................................................32
Referências..........................................................................................33

5. Lista de ilustrações
Ilustração 1: Site RegexPal.......................................................................................24
Ilustração 2: Site RegExr..........................................................................................25

6. Lista de quadros
Quadro 1: Cadeias de caracteres...............................................................................5
Quadro 2: Concatenação de linguagens..................................................................10
Quadro 3: Concatenação de linguagens 2...............................................................11
Quadro 4: Exemplos de expressões regulares..........................................................13
Quadro 5: Principais flags utilizadas na ferramenta egrep......................................26

7. 1 Pré-requisitos
N este capítulo apresentaremos alguns pré­
requisitos e introduziremos os primeiros
conceitos sobre expressões regulares de forma
puramente teórica.

8. Expressões Regulares: Teoria e Prática
Introdução
Em ciência da computação, uma expressão regular é uma forma concisa e
flexível de identificar cadeias de caracteres, caracteres particulares, palavras ou
padrões de caracteres. São largamente utilizadas em linguagens de programação,
ferramentas de busca de padrões e analisadores léxicos. Neste trabalho as expressões
regulares serão apresentadas em um primeiro momento de forma teórica baseado na
teoria da computação e em um segundo momento de forma prática.
Breve História das Expressões Regulares
As expressões regulares estão inseridas na teoria dos autômatos e na teoria das
linguagens formais, ambas fazem parte da teoria da computação. As origens das
expressões regulares remontam a década de 50, elas foram definidas pelo matemático
Stephen Cole Kleene no ano de 1956 no artigo “Representation of events in nerve nets
and finite automata”, Seu trabalho foi a base para os primeiros algoritmos
computacionais de busca e para algumas das mais antigas ferramentas de tratamento
de texto em ambientes UNIX.
Atualmente as Expressões Regulares são aplicadas na busca e substituição de
palavras em editores de texto, em linguagens de programação, validação de formatos
de texto (ou protocolos), filtragem de informação e etc.
Pré-requisitos
Antes de conhecer conceitos básicos sobre expressões regulares, definiremos
alguns conceitos fundamentais para a sua compreensão.
Alfabeto
Um Alfabeto é qualquer conjunto de símbolos finito não vazio. Geralmente
usamos a letra grega Σ para designar um alfabeto de símbolos. A seguir temos alguns
exemplos de alfabetos:
Σ1 = { 0, 1 };
2

9. 1 Pré­requisitos
Σ2 = { a, b , c, d, e }
Σ3 = { 0, 1, 2, a, b}
Os membros de um alfabeto são denominados símbolos do alfabeto.
Cadeia de caractere
O conceito de cadeia de caractere é fundamentalmente construído em ciência da
computação. Uma cadeia de caracteres é uma sequência finita de símbolos. Uma
cadeia de caracteres sobre um alfabeto é uma sequência finita de símbolos que
pertencem a um alfabeto, ou seja, uma forma particular de cadeia de caractere onde
cada elemento da cadeia pertence a um alfabeto. Tomando Σ1como alfabeto então

01001 é uma cadeia sobre Σ1. Agora se Σ4= { a, b, c, d, e, ..., z }, então abracadabra é

uma cadeia sobre Σ4.
Usualmente escrevemos cada elemento da cadeia de caractere junto um do outro
e sem vírgulas.
Tamanho
Se w for uma cadeia qualquer sobre um alfabeto Σ qualquer, o tamanho de w,
será escrito como |w|, o tamanho será o número de símbolos que w contém. Uma
cadeia de caracteres de tamanho zero é chamada de cadeia vazia e será escrita por
definição como ε.
Exemplo:
Σ = { 0, 1 };
w = 001001
| w | = 6
Sub-cadeia
Seja w uma cadeia de caracteres dizemos que z é uma sub­cadeia de w se z faz
parte de w. Por exemplo, a cadeia “abra” é uma sub­cadeia de “abracadabra”.
3

10. Expressões Regulares: Teoria e Prática
Concatenação
Podemos concatenar duas cadeias de caracteres, sejam x e y duas cadeias de
caracteres, escrevemos a concatenação de x e y como x1...xny1...ym, a cadeia que
obtemos ao concatenar o fim da cadeia x ao inicio da cadeia y é xy ou x ° y.
A concatenação de uma cadeia de caractere com ela mesma usa a seguinte
notação:
Onde k é o número de vezes que x é concatenado com ele próprio.
Exemplo:
Sejam x e y duas cadeias de caracteres onde x = “ola” e y = “mundo”
xy = “olamundo”
yx = “mundoola”
x2 = “olaola”
Linguagem
Uma linguagem é um conjunto de cadeias.
Conceitos básicos sobre Expressões Regulares
Em teoria da computação expressões regulares são descritores de linguagens, ou
seja, a partir destas expressões podemos identificar uma linguagem regular e escrevê­
la usando expressões.
Na matemática podemos usar os operadores de soma, e multiplicação para
construir expressões como a que segue:
( 2 + 3 ) × 5
4

11. 1 Pré­requisitos
De maneira análoga, podemos usar operações regulares para construir
expressões que descrevem linguagens, estas são chamadas expressões regulares. Um
exemplo de expressão regular é:
( 0 U 1 )0*
O resultado da expressão aritmética acima é o número 30. O resultado de uma
expressão regular é uma linguagem. Neste caso o resultado da expressão regular é a
3linguagem que consiste de todas as cadeias de caracteres possíveis começando com 0
ou 1 seguido por um número qualquer de 0's (zeros) inclusive nenhum, ou seja, a
linguagem representa o conjunto de todas as cadeias de caracteres que começam com
0 ou com 1 e terminam com um número qualquer de zeros. Assim a expressão regular
acima descreve dentre outras, as cadeias de caracteres mostradas no Quadro 1:
Cadeias de Inicio da cadeia Número de zeros no
caracteres final da cadeia
1 1 0 (zero)
10 1 1
000 0 2
1000 1 3
00000 0 4
100000 1 5
1000000 1 6
00000000 0 7
Quadro 1: Cadeias de caracteres
Para exemplificar o uso de expressões regulares, tome à seguinte linguagem: o
conjunto de cadeias de 0’s (zeros) e 1’s (um's) tais que comece com qualquer
quantidade de 1’s (inclusive nenhum), seguidos necessariamente de um 0 e outra
sequência com qualquer quantidade de 1’s.
5

12. Expressões Regulares: Teoria e Prática
Essa linguagem aparentemente complexa pode ser escrita facilmente em forma
de expressão regular:
1*01*
Note que apesar de representar um conjunto de cadeias de caracteres, ou seja,
uma linguagem, as expressões regulares também parecem cadeias. Assim as
expressões regulares estarão sempre destacadas em negrito.
6

13. 2 Conceitos
teóricos
N este capítulo apresentaremos a definição
formal de uma expressão regular, bem como
os operadores regulares união, concatenação e
estrela e suas regras de precedência.

14. Expressões Regulares: Teoria e Prática
Definição formal de uma expressão regular
Dizemos que R é uma expressão regular e se R descreve:
1. a para algum a em Σ;
2. ε;
3. ∅;
4. ( R1 U R2 ) onde R1 e R2 são expressões regulares;
5. ( R1 o R2 ) onde R1 e R2 são expressões regulares, ou
6. ( R1* ) onde R1 é uma expressão regular.
Nos itens 1 e 2 , a expressão regular a e ε representam respectivamente as
linguagens {a} e {ε}, então R será uma expressão regular se descreve uma cadeia a
qualquer sobre um alfabeto. No item 3 a expressão regular ∅ representa a linguagem

vazia, assim R também será uma expressão regular se descreve a linguagem vazia.
Nos itens 4, 5 e 6, a expressão regular descreve as linguagens obtidas através da
combinação de união ou concatenação das linguagens R1 e R2, ou estrela de uma
linguagem R1, respectivamente.
Não devemos confundir as expressões regulares ε e ∅. A expressão ε representa
a linguagem que contem uma única cadeia — chamada, cadeia vazia— no entanto
∅ representa a linguagem que não contem cadeias.
A seguir veremos detalhadamente os operadores de expressão regular e como
podemos usá­los para formar expressões mais complexas.
8

15. 2 Conceitos teóricos
Operações com Expressões Regulares
União
A ideia de união é a mesma aplicada à união de conjuntos na matemática
aplicado em linguagens. Vejamos, tome duas linguagens:
L1 = { a, b, c }
L2 = { 11, 01, a }
A união dessas duas linguagens é o conjunto de cadeias que está na primeira
linguagem mais as cadeias contidas na segunda, sem considerar repetições.
Denotamos a união de L1 e L2 como:
( L1 U L2 ) = {a, b, c, 11, 01}
Agora aplicaremos esse conceito em expressões regulares. Considere R1 e R2
duas expressões regulares. A união de R1 e R2 é definida como segue:
( R1 U R2 ) = { R1, R2 }
Para melhor compreendermos esse operador vejamos um exemplo.
Seja Σ= { a, b, c }, e ( ac U b ) uma expressão regular, vamos analisar essa

expressão e compreende­la. Dividindo a expressão em duas partes temos duas
expressões básicas:
A expressão ac que representa a linguagem { ac } sobre o alfabeto Σ e uma outra
expressão b que representa a linguagem { b } sobre o alfabeto Σ. Logo a expressão

regular ( ac U b ) representa a linguagem { ac, b }. Mas o que isso significa? O
operador U nos da a idéia de “ou”, assim entendemos portanto que ( ac U b )
representa a linguagem { ac } ou { b }.
É certo que com a prática acostumamos a entender as linguagens (e as
expressões que as representam) apenas com um olhar, sem precisar pensar em todos
esses passos.
9

16. Expressões Regulares: Teoria e Prática
Concatenação
O conceito de concatenação para expressões regulares é simples, tomando duas
expressões regulares:
R1 = ( 1 U 0 )
R2 = ( a U b )
A concatenação de R1 e R2 é representada da seguinte maneira:
R1R2 ou R1oR2
Para entendermos qual linguagem as expressões acima representam ao serem
concatenadas olharemos mais uma vez para as duas expressões individualmente:
R1 = ( 1 U 0 ) = { 1, 0 }
R2 = ( a U b ) = { a, b }
R1R2 = ( 1 U 0 )( a U b ) = { 1a, 1b, 0a, 0b}
A expressão R1 representa a linguagem { 1, 0 }, ou seja, uma cadeia de
caracteres que contém um 1 ou um 0, de maneira análoga a expressão R representa a
linguagem { a, b }, ou seja, uma cadeia de caracteres que contém um a ou um b. Ao
concatenar as duas expressões formamos uma outra expressão regular que representa
a linguagem obtida após a concatenação das duas linguagens representadas pelas
expressões. Para concatenar as duas linguagens basta fazer como segue no quadro 2:
R1 = ( 1 U 0 ) R2 = ( a U b ) R1R2 = ( 1 U 0 )( a U b )
1 a 1a
1 b 1b
0 a 0a
0 b 0b
Quadro 2: Concatenação de linguagens
Cuidado! Não esqueça que R1R2 ≠ R2R1 . A operação de concatenação não é
comutativa. Note que quando fazemos R1R2 temos:
( 1 U 0 )( a U b ) = { 1a, 1b, 0a, 0b }
10

17. 2 Conceitos teóricos
Se fizermos R2R1 teremos:
( a U b )( 1 U 0 ) = { a1, b1, a0, b0 }
Agora vamos analisar a concatenação de duas outras expressões regulares:
R1 = ( 1 U 0 )a
R2 = ( b )
R1 = ( 1 U 0 )a R2 = ( b ) R1R2 = ( 1 U 0 )a( b )
1a b 1ab
0a b 0ab
Quadro 3: Concatenação de linguagens 2
R1R2 = ( 1 U 0 )a( b ) = { 1ab, 0ab }
Logo as cadeias que começam com 1 ou 0 seguido de ab representam a
linguagem descrita pela concatenação das expressões.
Estrela
O operador * (estrela) é responsável por descrever uma quantidade infinita de
cadeias a partir de uma linguagem finita. Podemos definir o operador * em termos de
infinitas operações de concatenação e união:
Se R é uma expressão regular então R* pode representar:
Tome R = { a }
• Nenhuma cadeia de R, ou seja, { ε };
• Cadeias individuais de R, o próprio conjunto { a };
• Cadeias de R concatenadas aos pares, { aa }
• Cadeias de R concatenadas de três em três, { aaa }
• Etc.
Essa sequência continua infinitamente. Vejamos exemplos:
R1 descreve a linguagem que consiste de 0 ou mais concatenações da cadeia a
ou apenas a cadeia vazia.
11

18. Expressões Regulares: Teoria e Prática
R1 = a* = { ε , a, aa, aaa, aaaa, ... }
De maneira análoga R2 descreve a linguagem que consiste de 0 ou mais
concatenações da cadeia 0 ou da cadeia 01 ou ainda apenas a cadeia vazia.
R2 = ( 0 U 01 )* = { ε, 0, 01, 00, 0101, 000, 010101, ... }
Precedência de operadores em expressões regulares
Podemos omitir os parênteses de uma expressão regular se seguirmos as regras
de precedência dos operadores. No entanto os parênteses são ótimos para facilitar a
compreensão da expressão regular, além de darem maior precedência a um operador
em uma expressão.
Operador Maior precedência
* (estrela)
U (união)
o (concatenação)
Menor precedência
Algumas definições importantes
Seja R uma expressão regular por convenção, temos:
• R⁺ como sendo RR*, ou seja, a expressão R concatenada com R*
• R⁺ U ε = R*

• Rk é a concatenação de R k vezes
• R U ∅ = R
• R o ε = R

• R U ε = { L(R), ε }, onde L(R) é a linguagem descrita por R
 
• R o ∅ = ∅
Exemplos
Assumindo o alfabeto Σ = { 0, 1 }
12

19. 2 Conceitos teóricos
expressão regular Linguagem descrita pela expressão
0*10* Conjunto de cadeias sobre o
alfabeto Σ que contém um único 1
01 U 10 { 01, 10 }
Σ *001Σ * Conjunto de cadeias sobre o
alfabeto Σ que contém 001 como sub-
cadeia
(0 U ε)(1 U ε) { ε , 0, 1, 01 }
Quadro 4: Exemplos de expressões regulares
13

20. 3 Da teoria para
a prática
N os capítulos anteriores vimos toda a base
teórica necessária para compreendermos o
funcionamento das expressões regulares. Este
capítulo é uma ponte entre a teoria e a prática,
pois abordará as adaptações na sintaxe das ERs na
parte prática, bem como características adicionais.

21. 3 Da teoria para a prática
Caracteres especiais
As expressões regulares possuem caracteres que possuem propriedades especiais.
Ponto (.)
Este operador corresponde a qualquer caractere, menos nova linha (n).
Exemplo:
.a.a.o
O cavalo se assustou com o macaco.
Começo da string (^)
Este operador delimita o começo de uma string.
Exemplo:
^ma.{3}
mamãe, o mamão está verde.
Fim da string ($)
Este operador delimita o fim de uma string.
Exemplo:
.{2, 3}ma$
Calma, já vou deitar na cama
Operadores básicos
Os operadores básicos em expressões regulares são união (|), concatenação e
estrela (*). Entretanto, na prática, não existe um operador de concatenação explícito.
Além disso, são acrescentados os operadores de um ou mais (+) e zero ou um (?), que
são uma extensão dos operadores básicos.
União (|)
Na união, se a string possuir pelo menos um dos caracteres ou grupos de
caracteres da expressão, ela é válida.
15

22. Expressões Regulares: Teoria e Prática
Exemplo:
cão|cachorro|dog|perro
O cachorro está correndo.
Estrela (*)
A operação estrela repete zero ou mais vezes o caractere ou grupo anterior.
Exemplo:
Para noo*ssa alegria!
Para nooooooooooooooossa alegria! Para nossa alegria!
Um ou mais (+)
A operação um ou mais é uma extensão da estrela, pois repete uma ou mais
vezes o caractere ou grupo anterior.
Exemplo:
Para no+ssa alegria!
Para nooooooooooooooossa alegria! Para nossa alegria!
Zero ou um (?)
Esta operação é igual à operação de união entre uma cadeia vazia e outra
cadeia. Ou seja, ela pode ou não aparecer.
Exemplo:
[Ee]u (?:não)? te amo
Querida, eu te amo.
Ahh, que pena. Eu não te amo mais!
16

23. 3 Da teoria para a prática
Mais operadores
Repetições finitas
Quando se sabe a quantidade ou faixa de repetições que determinado caractere
ou grupo de caracteres possui, utiliza­se das repetições finitas.
Exemplo:
[Bb]lá{2, 5}|Bláu
Blá. Bláá, bláááááá, blááááá, Bláu
Conjuntos
São similares à união de vários caracteres. São representados por colchetes [].
Exemplo:
[A-Z]{3}{[123]{4}
A placa do meu carro é XKJ3143.
Grupos
Grupos servem para agrupar conjuntos de caracteres em uma única “entidade”.
São representador por (?:<caracteres>).
Exemplo:
(?:[Hh]e)+
He, hehehehehehehhe, hehe.
17

24. 4 Praticando com
expressões
regulares
N este capítulo serão abordados conceitos
práticos envolvendo expressões regulares no
dia a dia.

25. 4 Praticando com expressões regulares
Esta seção abordará a aplicabilidade das expressões regulares em programas
utilizados no mundo real, como validação de CEP, e­mail ou telefone.
CEP
Antes de criarmos a expressão regular para validar o CEP, temos que entender
como ele deve ser formatado.
O CEP possui oito dígitos, sendo que estes dígitos são divididos em três partes:
58.763-000
Agora que já sabemos como é a formatação do CEP, vamos criar nossa expressão
regular passo a passo.
O primeiro passo é substituir os números pela ER correspondente e utilizar um
caractere de escape () antes do pronto, para retirarmos suas propriedades especiais
na ER:
dd.ddd-ddd
Se nós testássemos esta expressão regular, ela funcionaria, no entanto, utilizar
tantos caracteres iguais seguidos não é uma boa prática.
Como sabemos quantos números cada grupo da expressão deve ter, vamos
especificá­los:
d{2}.d{3}-d{3}
Agora sim! Nossa ER está com uma cara mais bonita.
E-mail
A tarefa de criar ERs para validar e­mails de forma eficaz causa muita dor de
cabeça entre os desenvolvedores. Mas, felizmente, o objetivo deste livro não é lhe
causar problemas. Por isso, iremos construir apenas versões simples de expressões
regulares.
Primeira versão
Nesta primeira versão, iremos construir uma ER bem simples, que consegue
19

26. Expressões Regulares: Teoria e Prática
identificar apenas e­mails no formato usuario@exemplo.com.
Como fizemos no exemplo do CEP, vamos dividir o e­mail em grupos e, passo a
passo, criar as ERs correspondentes. Em alto nível, um e­mail possui dois grupos: o
que vem antes e depois do @.
Sabemos que um endereço de e­mail pode possuir letras, números, hífen (­),
underscore (_) ou ponto (.), mas nunca espaços.
[w-_.]+@[w-_.]+.com
Esta primeira versão é bastante simples. A ER [w-_.] significa o conjunto de
caracteres aceitável no nosso e­mail. Neste caso, estes caracteres são os que foram
mencionados no parágrafo anterior. Perceba que quando aquela ER aparece, ela vem
seguida de um +. Isto significa que ela pode ser repetida uma ou mais vezes.
Segunda versão
Nossa primeira versão consegue validar alguns tipos de e­mail. Mas sabemos que
existem e­mails que possuem domínios diferentes do .com. Para validarmos esses
novos tipos de e­mail, devemos estender nossa ER.
Primeiro, temos que identificar quais serão novos novos tipos de e­mail e como
eles são formatados. A seguir, você verá alguns exemplos:
usuario@exemplo.com.br
usuario@exemplo.us
usuario@exemplo.me
usuario@sub.exemplo.com.br
usuario@exemplo.name
Estes são apenas alguns exemplos de e­mails que nossa ER deve validar. Se você
perceber, existem diversos tipos de domínio no mundo. Portanto, neste caso, ao invés
de fazer uma coisa específica como fizemos com o caso do .com, devemos criar um
padrão genérico.
Nos exemplos, parte do usuário continua intacta. Isso significa que nós não
precisaremos muda­la. Já no caso dos domínios, devemos ter em mente que um e­mail
20

27. 4 Praticando com expressões regulares
pode ter vários subdomínios e que a última parte do site (com, br, us, name, etc.)
sempre possui entre dois e quatro caracteres (apenas letras).
A partir da análise acima, vamos criar uma nova ER para validar e­mails:
[w-_.]+@(?:[w-_.]+.)+[a-zA-Z]{2,4}
Agora chegamos a uma ER bem mais genérica que a anterior. Vamos entender o
que há de novo nesta nova ER. Vamos apenas nos deter ao que está após o @, pois o
que vem antes não foi modificado em relação à ER anterior.
A primeira mudança foi a inserção de parte da ER anterior dentro de um
delimitador de grupo (?:) seguido por um +, que indica que aquele grupo pode ser
repetido uma ou mais vezes, validando, assim, múltiplos subdomínios.
A última parte da ER ([a-zA-Z]{2,4}) valida a última parte do site, onde o
domínio só possui letras de tamanho entre dois e quatro.
Mesmo tendo melhorado a expressão regular e tornado­a mais genérica, como
foi falado no início deste tópico, a validação e e­mails é bastante complexa. Portanto,
alguns e­mails reais poderiam não passar ou e­mails falsos passarem na validação.
21

28. 5 Ferramentas
N este capítulo serão abordadas algumas
ferramentas que são utilizadas para criar e
manipular expressões regulares.

29. 5 Ferramentas
Hoje em dia, se você quiser pesquisar por um arquivo em seus diretórios, basta
digitar o nome do documento desejado no seu gerenciador de arquivos (e.g. Windows
Explorer, Nautilus, etc.) e, como mágica, dezenas de arquivos com nomes semelhantes
aparecem para você escolher. No entanto, a vida dos usuários de computador nem
sempre foi tão fácil assim.
Se você é usuário Unix/Linux e utiliza a linha de comandos ou alcançou os
tempos do MS­DOS, você provavelmente já deve ter utilizado os chamados caracteres
curingas (wildcards) para selecionar/modificar mais de um arquivo em um diretório.
Por exemplo, quando usamos o comando rm *.txt, estamos excluindo todos os
arquivos que terminam com a extensão .txt. Estes caracteres especiais são bastante
parecidos com as expressões regulares e são úteis para buscar padrões simples nos
textos. Se fossemos utilizá­las no exemplo anterior, deveríamos escrever um código
assim: rm .*.txt$.
Como você já viu nos capítulos anteriores, o ponto (.) simboliza qualquer
caractere que seja diferente de uma nova linha. No entanto, você deve prestar atenção
que o segundo ponto não é interpretado desta forma, pois existe uma contra­barra ()
antes dele. Sendo assim, ele é interpretado como um caractere comum.
Apesar de os caracteres curingas serem úteis para pequenas tarefas (como a que
foi mostrada acima) suas funcionalidades são limitadas para padrões mais complexos.
É aí onde entram as expressões regulares. Por meio delas, podemos gerar padrões
avançados que possibilitam filtrar dados dos mais diversos tipos em textos.
As expressões regulares são bastante utilizadas por desenvolvedores no dia a dia,
seja para validar números de CPF e e­mails ou para desenvolver um analisador léxico
de uma linguagem de programação.
23

30. Expressões Regulares: Teoria e Prática
Testando ERs na Web
Agora que você já sabe que as expressões regulares possuem alguma
aplicabilidade, vamos começar a brincar um pouco com elas.
Existem alguns sites disponíveis na web que conseguem interpretar expressões
regulares e retornar ou substituir os trechos de texto que correspondem ao padrão
inserido. Veja, a seguir, alguns sites que podem ajudá­lo a testar suas expressões
regulares.
RegexPal (http://regexpal.com/)
O RegexPal é um sistema simples desenvolvido em Javascript que interpreta
expressões regulares. Ele é útil para a construção de expressões, pois você pode testar
em tempo real se o padrão está funcionando corretamente.
Ilustração 1: Site RegexPal
24

31. 5 Ferramentas
RegExr (http://gskinner.com/RegExr/)
Possui as mesmas características do sistema anterior, mas possui também
explicações sobre cada padrão que está sendo formado. Além disso, existem alguns
exemplos na barra lateral que são bem úteis.
Ilustração 2: Site RegExr
A ferramenta egrep
Você viu anteriormente o exemplo de dois sites para manipular ERs e, se você
pesquisar no Google sobre “regular expressions online” irá encontrar muitos outros.
Contudo, também existem ferramentas no seu próprio computador que fazem uso de
expressões regulares, como é o caso da ferramenta egrep em sistemas Unix/Linux1.
A ferramenta egrep é utilizada na linha de comandos para imprimir linhas de
arquivos que possuem correspondências a padrões de expressões regulares.
1 A ferramenta egrep não vem instalada por padrão no Windows. Se você quiser baixar uma
ferramenta similar, acesse o seguinte site: http://unxutils.sourceforge.net/.
25

32. Expressões Regulares: Teoria e Prática
Sua sintaxe é a seguinte:
egrep [flags] <expressao-regular> [nome-do-arquivo]
Onde o primeiro argumento é uma expressão regular (ou flags, opcionalmente) e
o segundo (opcional) é o arquivo de texto a ser verificado.
Flags
O egrep possui uma série de opções que facilitam o seu manuseio, estas opções
recebem o nome de flags. A seguir, você terá uma tabela com algumas das flags
suportadas pelo egrep.
Flag Descrição
Serve para mostrar uma breve descrição
--help da ferramenta e seu modo de
funcionamento.
Imprime a quantidade de linhas
--count
capturadas ao invés de mostrá­las.
Colore as partes do texto que
--color
correspondem ao padrão da ER.
Exibe apenas as partes correspondentes
--only-matching
ao padrão e não toda a linha.
Quadro 5: Principais flags utilizadas na ferramenta egrep
Vamos ver quantas palavras no dicionário de português contêm o padrão
“discurso”:
egrep --count "discurso" /usr/share/dict/brazilian
3
Agora, ao invés de imprimir a quantidade, vamos saber quais são as palavras que
possuem o padrão. Utilizando a flag --color, iremos colorir a parte das palavras que
corresponde ao padrão da ER.
egrep --color "discurso" /usr/share/dict/brazilian
discurso
discursos
Como você pôde ver nos exemplos acima, as flags são muito úteis. Se você quiser
discursou
26

33. 5 Ferramentas
saber mais sobre como manusear a ferramenta egrep e quais são todas as flags que
ela possui, digite o comando egrep --help.
Começo e fim de ERs
Se você quiser listar todas as suas pastas no diretório atual que comecem com
“d” e terminem com “s”, você pode usar o seguinte comando:
ls | egrep “[dD].*[sS]”
Desktop
Documentos
Downloads
Modelos
Vídeos
Mas alguma coisa deu errado. Quando você mandou imprimir os diretórios que
começassem com “d” e terminassem com “s”, ele também imprimiu “Desktop”,
“Modelos” e “Vídeos”. Mas por quê?
Se você prestar atenção na sua ER, você verá que ela irá capturar tudo o que
possuir um “d” (ou “D”), zero ou algum caractere no meio e depois “s” (ou “S”). Tanto
“Desktop”, “Modelos” ou “Vídeos” possuem esse padrão, mesmo que ele esteja
contido no meio de cada palavra.
Para solucionar este problema, devemos utilizar dois caracteres que possuem
funções especiais nas ERs, o ^ e o $, que significam, respectivamente, começo e fim da
string a ser capturada.
Então, nosso comando para capturar palavras que começam com “d” e terminam
com “s” ficará assim:
ls | egrep “^[dD].*[sS]$”
Documentos
Downloads
Como você pôde ver, agora o comando imprimiu apenas as palavras que
começam com “d” e terminam com “s”.
27

34. 6 Expressões
regulares com
Python
A gora que já sabemos o quanto as expressões
regulares são poderosas, iremos uni­las às
facilidades da linguagem de programação Python
para construir nossos primeiros programas
utilizando expressões regulares em sua essência.

35. 6 Expressões regulares com Python
A linguagem Python
Python é uma linguagem interpretada, de fácil entendimento que é utilizada no
desenvolvimento dos mais diversos tipos de aplicações, sejam elas para desktop, web,
moveis, etc.
Como o foco deste livro não é ensinar programação, se você não souber a
linguagem Python, indico que leia o tutorial2 oficial da linguagem.
Aprendendo o módulo re
Assim como outras linguagens de programação, Python possui diversos módulos
(ou bibliotecas). O módulo responsável por criar e manusear expressões regulares em
Python chama­se re, de Regular Expressions.
Por meio do módulo re nós conseguiremos criar tudo o que já fizemos com a
ferramenta egrep e, adicionalmente, aliar o poder de uma linguagem de programação
para desenvolver nossos primeiros programas.
O módulo re suporta3 todos os caracteres especiais estudados anteriormente,
como ., ^, $, *, +, ?, [], {}, () e |, além dos caracteres que aceitam conjuntos, como
d, w e s.
Para criar e manusear as expressões regulares, devemos utilizar as funções
disponíveis no módulo re. Veja a seguir uma descrição das principais funções.
match
Tenta aplicar o padrão ao início da string. Se houver uma correspondência, é
retornado um objeto com a parte correspondente da string. Caso contrário, é
retornado um objeto do tipo None4.
2 Site com o tutorial oficial da linguagem Python em português:
http://www.python.org.br/wiki/TutorialPython
3 Para ver todos os caracteres especiais e funções suportadas pelo módulo re, acesse o site:
http://docs.python.org/library/re.html
4 None é um tipo especial em Python que significa vazio, nulo.
29

36. Expressões Regulares: Teoria e Prática
Sintaxe:
re.match(<padrão>, <string>) → MatchObject ou None
Exemplo:
import re
padrao = r'inw+'
resultado = re.match(padrao, 'interesse')
print(resultado)
resultado = re.match(padrao, 'desinteresse')
print(resultado)
<_sre.SRE_Match object at 0xb700bfa8>
Na primeira linha é importado o módulo re.
None
A string que representa o padrão deve conter um r antes das aspas, o que indica
uma string bruta (raw string) em Python, ou seja, uma string que não interpreta
caracteres especiais como 'n', por exemplo.
Como foi mostrado na saída do programa, o primeiro resultado possui
correspondência enquanto o segundo não. Isso acontece porque a função match
começa a verificar o padrão desde o começo da string.
search
Esta função é semelhante à função match, no entanto, ela escaneia toda a string
em busca do padrão ao invés de verificá­lo só no início.
Sintaxe:
re.search(<padrão>, <string>) → MatchObject ou None
Exemplo:
import re
padrao = r'inw+'
resultado = re.match(padrao, 'interesse')
print(resultado)
resultado = re.match(padrao, 'desinteresse')
30

37. 6 Expressões regulares com Python
print(resultado)
<_sre.SRE_Match object at 0xb7001528>
Na primeira linha é importado o módulo re.
<_sre.SRE_Match object at 0xb7001e90>
Neste caso, foram retornados objetos nos dois resultados, pois o padrão também
está contido na segunda string.
findall
Esta função retorna uma lista de todas as ocorrências do padrão na string.
Sintaxe:
re.findall(<padrão>, <string>) → lista de ocorrências
Exemplo:
import re
padrao = r'inw+'
resultado = re.match(padrao, 'Eu estou sem interesse, mas
você está muito interessado.')
print(resultado)
['interesse', 'interessado']
sub
Esta função retorna uma string obtida por meio da substituição das ocorrências
do padrão na string original por uma outra string.
Sintaxe:
re.sub(<padrão>, <string-sub>, <string-original>) → string
Exemplo:
import re
resultado = re.sub(r'Luis', 'Luiz', 'Oi Luis, tudo bem?')
print(resultado)
Oi Luiz, tudo bem?
31

38. Expressões Regulares: Teoria e Prática
Considerações Finais
Durante a leitura deste material, você pôde aprender desde a parte
teórica de expressões regulares vista em cursos de Teoria da Computação,
como a parte prática, aplicando esta poderosa ferramenta a problemas
cotidianos.
Como o objetivo deste livro é apenas introduzir os conceitos básicos sobre
expressões regulares, muita coisa ficou de fora. Além disso, por causa do
curto prazo de tempo para a elaboração desta primeira versão, alguns
conteúdos não puderam ser abordados com mais detalhes.
Para a próxima versão, espera­se que o material seja ampliado e que
possua mais exemplos e exercícios.
32

39. Referências
Referências
BECKLES, B.; DOWLING , B. Python: Regular Expressions. [s.l.]: [s.n], 2010.
FRIEDL , J. E. F. Mastering Regular Expressions. 3. ed. Sebastopol: O'Reilly, 2010
GALINO, W.; ROSA, W.; SAMPAIO, P. A. Introdução a Teoria da Computação. [ Sn:.Sl
], 2008. 130 p.
SIPSER, M. Introduction of the Theory of Computation.[Boston, Massachusetts ]:
Thomson Course Technology, 2006. 436 p. ISBN 0­534­95097­3 .
33