re – Operações de expressão regular

Sintaxe de Expressão Regular

Uma expressão regular (ou RE) especifica um conjunto de strings que combina com ela; as funções neste módulo permitem verificar se uma determinada string combina com uma determinada expressão regular (ou se uma determinada expressão regular combina com uma determinada string, que se resume à mesma coisa).

Expressões regulares podem ser concatenadas para formar novas expressões regulares; se A e B são ambas expressões regulares, então AB é também uma expressão regular. Em geral, se uma string p corresponde a A e outra string q corresponde a B, a string pq corresponderá a AB. Isto é válido a menos que A ou B contenham poucas operações de precedência; condições de limite entre A e B; ou tenham referências de grupo numeradas. Assim, expressões complexas podem ser facilmente construídas a partir de expressões mais simples e primitivas como as aqui descritas. Para detalhes sobre a teoria e implementação de expressões regulares, consulte o livro Friedl, ou quase qualquer livro sobre construção de compiladores.

Segue-se uma breve explicação do formato das expressões regulares. Para mais informações e uma apresentação mais gentil, consulte o HOWTO.

Expressões regulares podem conter tanto caracteres especiais como ordinários. Os caracteres mais ordinários, como 'A', 'a', ou '0', são as expressões regulares mais simples; eles simplesmente combinam com eles mesmos. Você pode concatenar caracteres comuns, então last combina com a string 'last'. (No resto da secção, vamos escrever RE’s em this special style, normalmente sem aspas, e strings a combinar 'in single quotes'.)

Alguns caracteres, como '|' ou '(', são especiais. Caracteres especiais ou significam classes de caracteres comuns, ou afirmam que as expressões regulares ao seu redor são interpretadas.

Qualificadores de repetição (*, +, ?, {m,n}, etc.) não podem ser aninhados de forma estranha. Isto evita ambiguidade com o sufixo modificador não-grecioso?, e com outros modificadores em outras implementações. Para aplicar uma segunda repetição a uma repetição interna, podem ser usados parênteses. Por exemplo, a expressão (?:a{6})* corresponde a qualquer múltiplo de seis 'a' caracteres.

Os caracteres especiais são:

.

(Dot.) No modo padrão, isto corresponde a qualquer caractere exceto uma nova linha. Se a bandeira DOTALL foi especificada, isto corresponde a qualquer caractere, incluindo uma nova linha.

^

(Caret.) corresponde ao início da string, e no modo MULTILINE corresponde imediatamente após cada nova linha.

$

corresponde ao final da string ou pouco antes da nova linha no final da string, e no modo MULTILINE corresponde também antes de uma nova linha. fooCorresponde a ambos ‘foo’ e ‘foobar’, enquanto a expressão regular foo$ corresponde apenas a ‘foo’. Mais interessante, procurando por foo.$ em 'foo1\nfoo2\n'conjunta ‘foo2’ normalmente, mas ‘foo1’ no modo MULTILINE; procurando fora do modo simples $ em 'foo\n' irá encontrar dois pares (vazios): um pouco antes da nova linha, e um no final da string.

*

Faz com que o RE resultante combine com 0 ou mais repetições do RE anterior, tantas repetições quanto forem possíveis. ab*Fará corresponder a ‘a’, ‘ab’, ou ‘a’ seguido de qualquer número de ‘b’s.

+

Fará coincidir o RE resultante com 1 ou mais repetições do RE anterior.ab+Fará corresponder a ‘a’ seguido de qualquer número não-zero de ‘b’s; não coincidirá apenas com ‘a’.

?

Faz corresponder a RE resultante a 0 ou 1 repetições da RE.ab? anterior; ou ‘a’ ou ‘ab’.

*?,+?,??

As '*', '+', e '?' qualificadores são todos gananciosos; eles correspondem com o máximo de texto possível. Às vezes este comportamento não é desejado; se o RE<.*> for comparado com '<a> b <c>', ele irá corresponder ao entirestring, e não apenas '<a>'. Adicionar ? após o qualificativo faz com que ele tenha um desempenho não mesquinho ou mínimo; o menor número possível de caracteres será igualado. Usando o RE <.*?> irá corresponder apenas '<a>'.

{m}

Especifica que exactamente m cópias do RE anterior devem ser correspondidas; poucosermatches fazem com que o RE inteiro não corresponda. Por exemplo, a{6} irá combinar exactamente seis 'a' caracteres, mas não cinco.

{m,n}

Causa a RE resultante a combinar de m para n repetições da RE anterior, tentando combinar o máximo de repetições possível. Por exemplo,a{3,5} irá combinar de 3 a 5 'a' caracteres. Omitindo m especifica um limite inferior de zero, e omitindo n especifica um limite superior infinito. Como anexo, a{4,}b irá combinar 'aaaab' ou mil 'a' caracteres seguidos por um 'b', mas não 'aaab'. A vírgula não pode ser omitida ou o sequenciador de caracteres seria confundido com a forma anteriormente descrita.

{m,n}?

Faz corresponder o RE resultante de m a n repetições doRE precedente, tentando corresponder o menor número possível de repetições. Esta é então a versão do qualificador anterior. Por exemplo, na sequência de 6 caracteres 'aaaaaa', a{3,5} irá corresponder a 5 'a' caracteres, enquanto a{3,5}? irá corresponder apenas a 3 caracteres.

\

Evite caracteres especiais (permitindo-lhe corresponder a caracteres como '*', '?', etc.), ou sinalize uma sequência especial; as sequências especiais são discutidas abaixo.

Se você não estiver usando uma string bruta para expressar o padrão, lembre-se que Pythonalso usa a barra invertida como uma seqüência de escape em caracteres literais; se a seqüência de escape não for reconhecida pelo parser de Python, a barra invertida e o caractere subseqüente estão incluídos na string resultante. Entretanto, se Python reconhecer a seqüência resultante, a barra invertida deve ser repetida duas vezes. Isto é complicado e difícil de entender, por isso é altamente recomendado que você use strings para todas as expressões, exceto as mais simples.

Usado para indicar um conjunto de caracteres. Em um conjunto:

• Caracteres podem ser listados individualmente, por exemplo, irá corresponder a 'a','m', ou 'k'.

• Os intervalos de caracteres podem ser indicados dando dois caracteres e separando-os por um '-', por exemplo corresponderá a qualquer letra ASCII em minúsculas, corresponderá a todos os números de dois dígitos de 00 a 59, e corresponderá a qualquer dígito hexadecimal. Se - for escapado (por exemplo, ) ou se for colocado como primeiro ou último caractere (por exemplo, ou ), irá corresponder a um literal '-'.

• Caracteres especiais perdem o seu significado especial dentro de conjuntos. Por exemplo, corresponderá a qualquer um dos caracteres literais '(', '+','*', ou ')'.

• As classes de caracteres como \w ou \S (definidas abaixo) também são aceitas dentro de um conjunto, embora os caracteres correspondentes dependam se o modoASCII ou LOCALE está em vigor.

• Caracteres que não estão dentro de um intervalo podem ser combinados complementando o conjunto. Se o primeiro caractere do conjunto for '^', todos os caracteres que não estão no conjunto serão combinados. Por exemplo, será igual a qualquer caractere exceto '5', e será igual a qualquer caractere exceto '^'. ^ não tem nenhum significado especial se não for o primeiro caractere no set.

• Para combinar um literal ']' dentro de um set, precedê-lo com uma contrabarra, ou colocá-lo no início do set. Por exemplo, ambos {}] e() combinarão ambos um parênteses.

• Suporte de conjuntos aninhados e operações de conjuntos como no Unicode TechnicalStandard #18 podem ser adicionados no futuro. Isto mudaria esta sintaxe, então para facilitar esta mudança um FutureWarning será levantado em casos ambíguos por enquanto. Isto inclui sets começando com um literal '.

  (...)

  Corresponde a qualquer expressão regular dentro dos parênteses, e indica o início e fim de um grupo; o conteúdo de um grupo pode ser recuperado após uma partida ter sido realizada, e pode ser combinado mais tarde na string com a seqüência especial \number, descrita abaixo. Para combinar os literais '(' ou ')',use \( ou \), ou coloque-os dentro de uma classe de caracteres: , .

  (?...)

  Esta é uma notação de extensão (uma notação '?' seguindo um '(' não é significativa de outra forma). O primeiro caractere após o '?' determina qual é o significado e a sintaxe da construção. Extensões geralmente não criam um novo grupo; (?P<name>...) é a única exceção a esta regra. A seguir estão as extensões suportadas atualmente.

  (?aiLmsux)

  (Uma ou mais letras do conjunto 'a', 'i', 'L', 'm','s', 'u', 'x'.) O grupo corresponde à cadeia vazia; as cartas definem as bandeiras correspondentes: re.A (correspondência somente ASCII),re.I (ignore case), re.L (locale dependent),re.M (multi-line), re.S (dot matches all),re.U (Unicode matching), e re.X (verbose), para toda a expressão regular.(As flags são descritas no Conteúdo do Módulo.)Isto é útil se você desejar incluir as flags como parte da expressão teregular, ao invés de passar um argumento de flag para a funçãore.compile(). As bandeiras devem ser usadas primeiro na string de expressão.

  (?:...)

  Uma versão não-capturável de parênteses regulares. Combina com qualquer expressão regular dentro dos parênteses, mas o substrato combinado pelo groupcannot pode não ser recuperado após a realização de uma correspondência ou referenciado posteriormente no padrão.

  (?aiLmsux-imsx:...)

  (Zero ou mais letras do conjunto 'a', 'i', 'L', 'm','s', 'u', 'x', opcionalmente seguido de '-' seguido de uma ou mais letras do conjunto 'i', 'm', 's', 'x'.)As letras definem ou removem as bandeiras correspondentes:re.A (ASCII-only matching), re.I (ignore case),re.L (locale dependent), re.M (multi-line),re.S (dot matches all), re.U (Unicode matching),e re.X (verbose), para a parte da expressão.(As bandeiras são descritas no Conteúdo do Módulo.)

  As letras 'a', 'L' e 'u' são mutuamente exclusivas quando usadas como bandeiras em linha, portanto não podem ser combinadas ou seguidas '-'. Em vez disso, quando uma delas aparece em um grupo inline, ela substitui o modo de correspondência no grupo que a rodeia. Em padrões Unicode (?a:...) muda para correspondência Unicode, e (?u:...) muda para correspondência Unicode (padrão). Em byte pattern (?L:...) muda para locale dependingmatching, e (?a:...) muda para ASCII-only matching (default). Esta substituição só está em efeito para o grupo em linha estreita, e o modo de correspondência original é restaurado fora do grupo.

  Novo na versão 3.6.

  Modificado na versão 3.7: As letras 'a', 'L' e 'u' também podem ser usadas num grupo.

  (?P<name>...)

  Similar a parênteses regulares, mas o substrato igualado pelo grupo é acessível através do nome simbólico do grupo. Os nomes dos grupos devem ser identificadores válidosPython, e cada nome de grupo deve ser definido apenas uma vez dentro da expressão aregular. Um grupo simbólico é também um grupo numerado, como se o grupo não fosse nomeado.

  Grupos nomeados podem ser referenciados em três contextos. Se o padrão for(?P<quote>).*?(?P=quote) (ou seja combinando uma string citada com eithersingle ou aspas duplas):

  Contexto de referência ao grupo “quote”	Modos de referenciá-lo
  no mesmo padrão em si	(?P=quote) (como mostrado)
  quando o processamento corresponder ao objecto m	m.group('quote') m.end('quote') (etc.)
  > num fio passado para o replargumento de re.sub()	\g<quote> \g<1>

  (?P=name)

  Uma referência a um grupo nomeado; corresponde a qualquer texto que tenha sido correspondido pelo nome do grupo mais antigo.

  (?#...)

  Um comentário; o conteúdo dos parênteses é simplesmente ignorado.

  (?=...)

  Corresponde se ... corresponde ao próximo, mas não consome nenhuma string. Isto é chamado de uma asserção lookahead. Por exemplo, Isaac (?=Asimov) só se igualará'Isaac ' se for seguida por 'Asimov'.

  (?!...)

  Corresponde se ... não corresponder a próxima. Por exemplo, Isaac (?!Asimov) só coincidirá com 'Isaac ' se não for seguido por 'Asimov'.

  (?<=...)

  Compartilha se a posição atual na string for precedida por uma correspondência para ... que termina na posição atual. Isto é chamado de “lookbehindassertion” positivo. (?<=abc)def encontrará uma correspondência em 'abcdef', uma vez que o lookbehind irá fazer backup de 3 caracteres e verificar se o padrão contido corresponde. O padrão contido deve corresponder apenas a cadeias de caracteres de algum comprimento fixo, o que significa queabc ou a|b são permitidos, mas a* e a{3,4} não são. Note que padrões que começam com afirmações de lookbehind positivas não corresponderão no início da string que está sendo pesquisada; você provavelmente vai querer usar a funçãosearch() ao invés da funçãomatch() function:

  >>> import re>>> m = re.search('(?<=abc)def', 'abcdef')>>> m.group(0)'def'

  Este exemplo procura por uma palavra seguindo um hífen:

  >>> m = re.search(r'(?<=-)\w+', 'spam-egg')>>> m.group(0)'egg'

  Modificado na versão 3.5: Adicionado suporte para referências de grupo de comprimento fixo.

  (?<!...)

  Modificado se a posição actual na string não for precedida por uma correspondência para.... Isto é chamado de afirmação negativa de lookbehind. Afirmações similares de lookbehind topositivas, o padrão contido deve corresponder apenas a cordas de algum comprimento fixo. Padrões que começam com afirmações negativas de lookbehind podem corresponder no início da string a ser pesquisada.

  (?(id/name)yes-pattern|no-pattern)

  Tentará corresponder com yes-pattern se o grupo com determinado orname id existir, e com no-pattern se não existir. no-pattern isopcional e pode ser omitido. Por exemplo,(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) é um mau padrão de correspondência de e-mail, que coincidirá com '<[email protected]>' assim como '[email protected]', mas não com '<[email protected]' nem com '[email protected]>'.

  As sequências especiais consistem em '\' e um caractere da lista abaixo. Se o caractere comum não for um dígito ASCII ou uma letra ASCII, então o RE resultante coincidirá com o segundo caractere. Por exemplo, $ corresponde ao caractere '$'.

  \number

  Corresponde ao conteúdo do grupo do mesmo número. Grupos são numerados a partir de 1. Por exemplo, (.+) corresponde a 'the the' ou '55 55',mas não 'thethe' (note o espaço após o grupo). Esta sequência especial só pode ser usada para corresponder a um dos primeiros 99 grupos. Se o primeiro dígito do número for 0, ou o número tiver 3 dígitos octais, ele não será interpretado como um grupo asa correspondente, mas como o caractere com o número do valor octal. Dentro do'' de uma classe de caracteres, todos os escapes numéricos são tratados como caracteres.

  \A

  Corresponde apenas ao início da string.

  \b

  Corresponde à string vazia, mas apenas ao início ou fim de uma palavra.Uma palavra é definida como uma sequência de caracteres de palavras. Note que formalmente,\b é definido como o limite entre um caractere \w e um caractere \W(ou vice-versa), ou entre \w e o início/fim da cadeia de caracteres.Isto significa que r'\bfoo\b' combina 'foo', 'foo.', '(foo)','bar foo baz' mas não 'foobar' ou 'foo3'.

  Por padrão, os alfanuméricos Unicode são os usados nos padrões Unicode, mas isto pode ser alterado usando a bandeira ASCII. Os limites das palavras são determinados pelo locale atual se o flag LOCALE for usado. Dentro de um intervalo de caracteres, \b representa o caractere de backspace, forcompatibilidade com a string literal de Python.

  \B

  Corresponde à string vazia, mas somente quando ela não está no início ou não contém uma palavra. Isto significa que r'py\B' coincide com 'python', 'py3','py2', mas não 'py', 'py.', ou 'py!'.\B é exactamente o oposto de \b, por isso os caracteres das palavras em Unicodepatterns são alfanuméricos Unicode ou o underscore, embora isto possa ser alterado utilizando a bandeira ASCII. Os limites das palavras são determinados pelo locale atual se a bandeira LOCALE for usada.

  \d Para padrões Unicode (str):

  Corresponde a qualquer dígito decimal Unicode (ou seja, qualquer caractere na categoria de caracteres Unicode ). Isto inclui , e também muitos outros caracteres de dígitos. Se a bandeira ASCII for usada apenas é igualada.

  Para padrões de 8 bits (bytes):

  Corresponde a qualquer dígito decimal; isto é equivalente a .

  \D

  Corresponde a qualquer caractere que não seja um dígito decimal. Isto é o oposto de \d. Se a bandeira ASCII for usada, isto é o equivalente a .

  \s Para padrões Unicode (str):

  Corresponde a espaços em branco Unicode (que inclui, e também muitos outros caracteres, por exemplo, espaços de quebra de linha mandados pelas regras de tipografia em manylanguages). Se a bandeira ASCII for usada, apenas é igualada.

  Para padrões de 8 bits (bytes):

  Corresponde a caracteres considerados espaços em branco no conjunto de caracteres ASCII; isto é equivalente a .

  \S

  Corresponde a qualquer caractere que não seja um espaço em branco. Isto é o oposto de \s. Se a bandeira ASCII for usada, isto é o equivalente a .

  \w Para padrões Unicode (str):

  Conjunta caracteres de palavras Unicode; isto inclui a maioria dos caracteres que podem ser parte de uma palavra em qualquer língua, assim como números e o sublinhado. Se a bandeira ASCII for usada, apenas é igualada.

  Para padrões de 8 bits (bytes):

  Conjunta caracteres considerados alfanuméricos no conjunto de caracteres ASCII; isto é equivalente a . Se a bandeira LOCALE for utilizada, combina com caracteres considerados alfanuméricos no local atual e o sublinhado.

  \W

  Combina com qualquer caractere que não seja um caractere de palavra. Isto é o oposto de \w. Se a bandeira ASCII for usada, isto equivale a . Se a bandeira LOCALE for usada, corresponde a caracteres que não são alfanuméricos no local atual ou o sublinhado.

  > \Z

  Compatibilidade apenas no final da string.

  A maior parte das fugas padrão suportadas por literais de string Python também são aceitas pela expressão regular parser:

  \a \b \f \n\N \r \t \u\U \v \x \

  (Note que \b é usado para representar limites de palavras, e significa “backspace” somente dentro de classes de caracteres.)

  '\u', '\U', e '\N' seqüências de escape somente são reconhecidas em Unicodepatterns. Em padrões de bytes eles são erros. Fugas desconhecidas de ASCIIletters são reservadas para uso futuro e tratadas como erros.

  Fugas octais são incluídas de forma limitada. Se o primeiro dígito for um 0, ou se houver três dígitos octais, é considerado um escape octal. Caso contrário, é uma referência de grupo. Quanto aos caracteres literais, os escapes octais são sempre no máximo três dígitos em comprimento.

  Mudado na versão 3.3: As sequências de escape '\u' e '\U' foram adicionadas.

  Mudado na versão 3.6: Fugas desconhecidas consistindo de '\' e uma letra ASCII agora são erros.

  Modificado na versão 3.8: A sequência de fugas '\N{name}' foi adicionada. Como em literais de string, ele se expande para o caractere Unicode (por exemplo '\N{EM DASH}').