Expressão regular do Python

Neste tópico, aprenderemos expressões regulares do Python.

Definição: Expressões regulares, às vezes chamadas de re ou regex ou regexp, são sequências de caracteres para corresponder aos padrões em texto/string. O Python tem um módulo de RE embutido para executar isso.

Os usos comuns de uma expressão regular são:

1. Pesquise uma string (pesquise e encontre)
2. Encontre toda a string correspondente (Findall)
3. Split String na substring (divisão)
4. Substitua parte de uma string (sub)

Uma expressão regular é uma combinação de alfabetos, metacharacters. Então, os seguintes metacaracters estão disponíveis.

• \ Isso é usado para soltar/ignorar o significado especial do caráter
• [] Isso indica uma classe de caracteres ex: [a-z], [a-za-z0-9]
• ^ Isso corresponde ao início do texto
• $ Isso corresponde ao fim do texto
• . Isso corresponde a qualquer personagem, exceto a nova linha
• ? Combinar zero ou uma ocorrência.
• | Significa ou (combine com qualquer um dos personagens separados por ele.
• * Qualquer número de ocorrências (incluindo 0 ocorrências)
• + Uma ou mais ocorrências
• Indica várias ocorrências de um re anterior para combinar.
• () Inclua um grupo de regexp

Se usarmos a barragem '\', indica várias sequências. Eu quero usar barra de barro sem o seu significado especial '\\'.

• \ D corresponde a qualquer dígito decimal, é o mesmo que a classe Set [0-9]
• \ D corresponde a qualquer caractere não dígito
• \ s corresponde a qualquer caractere em branco.
• \ S corresponde a qualquer caractere não-branco
• \ w corresponde a qualquer caráter alfanumérico; É o mesmo que uma classe [A-ZA-Z0-9_].
• \ W corresponde a qualquer caráter não alfanumérico.

O método a seguir disponível no módulo RE:

re.procurar() :

Este método retorna a parte correspondente da string e para após a primeira partida. Portanto, isso pode ser usado para testar uma expressão em vez de extrair dados.

Sintaxe: re.Pesquisar (padrão, string)
Valor de retorno:
Nenhum : O padrão não corresponde
Corda : padrão correspondente

Ex: Neste exemplo, pesquisará o mês e a data

importar re
regexp = r "([a-za-z]+) (\ d+)"
Match = re.Pesquisar (Regexp, "My Son Birthday é em 20 de julho")
se corresponder != Nenhum:
print ("corresponda ao índice %s, %s" %(correspondência.start (), combinar.end ())))#Isso fornece índice de string correspondente
impressão ("correspondência completa: % s" % (correspondência.Grupo (0))))
print ("mês: % s" % (correspondência.grupo 1)))
print ("dia: % s" % (correspondência.grupo (2)))
outro:
print ("O padrão regex fornecido não corresponde")

ré.corresponder() :

Este método procura e retorna a primeira partida. Isso verifica a partida apenas no início da string.

Sintaxe: re.Match (padrão, string)
Valor de retorno:
Nenhum: o padrão não corresponde
String: padrão correspondente

Ex: este exemplo para mostrar o início do padrão de string correspondente

importar re
regexp = r "([a-za-z]+) (\ d+)"
Match = re.Match (regexp, "20 de julho")
Se corresponde == Nenhum:
print ("Não é uma data válida")
outro:
print ("dado string: % s" % (correspondência.grupo()))
print ("mês: % s" % (correspondência.grupo 1)))
print ("dia: % s" % (correspondência.grupo (2)))

Ex: para mostrar o padrão não correspondido no começo

importar re
Match = re.Match (Regexp, "My Son Birthday é em 20 de julho")
Se corresponde == Nenhum:
print ("Não é uma data válida")
outro:
print ("dado string: % s" % (correspondência.grupo()))
print ("mês: % s" % (correspondência.grupo 1)))
print ("dia: % s" % (correspondência.grupo (2)))

ré.encontrar tudo() :

Este método retorna todas as correspondências de padrão em uma string. A string é pesquisada do início ao fim e as correspondências são devolvidas na ordem encontrada.

Sintaxe : re.Findall (padrão, string)
Valor de retorno
String vazia ([)]: o padrão não corresponde
Lista de string: padrão correspondente

Ex: Expressão regular para encontrar dígitos

importar re
String = "" "Bangalore Pincode é 560066 e
Gulbarga Pincode é 585101 "" "
regexp = '\ d+'
Match = re.Findall (regexp, string)
Imprimir (correspondência)

Ex: Encontre o número do celular (número exato de 10 dígitos) do texto determinado

importar re
String = "" "Office Bangalore número 1234567891,
Meu número é 8884278690, contato de emergência 3456789123
número inválido 898883456 "" "
regexp = '\ d 10'#esta expressão regular para corresponder ao número exato de 10 dígitos
Match = re.Findall (regexp, string)
Imprimir (correspondência)

ré.compilar():

Expressões regulares são compiladas em objetos de padrões e podem ser usadas nos métodos. Exemplo de busca por correspondências de padrões, substituições de string.

Ex:

importar re
e = re.compilação ('[a-e]')
impressão (e.Findall ("nasci aos 11 a.M. em 20 de julho de 1989 "))
e = re.Compile ('\ d') # \ d é equivalente a [0-9].
impressão (e.Findall ("nasci aos 11 a.M. em 20 de julho de 1989 "))
p = re.Compile ('\ d+')#Grupo de um ou mais dígitos
impressão (p.Findall ("nasci aos 11 a.M. em 20 de julho de 1989 "))

ré.dividir():

String dividida com base nas ocorrências de um padrão. Se encontrado padrão, os caracteres restantes da string são retornados como parte da lista resultante. Podemos especificar a divisão máxima para uma determinada string.

Sintaxe - ré.dividir (padrão, string, maxsplit = 0)
Valores de retorno:
Lista vazia ([]): o padrão não corresponde
Lista de string: padrão correspondente

Ex:

importar re
# '\ W+' corresponde a caracteres não alfanuméricos ou grupo de caracteres
# se dividi ao encontrar '' ou WhiteSpace "
impressão (re.dividir ('\ w+', 'bom, melhor, melhor')))
impressão (re.Split ('\ w+', "livros de livros do livro"))))
# Aqui ':', ", ',' não são alfanuméricos onde a divisão ocorre
impressão (re.Split ('\ w+', 'nascido em 20 de julho de 1989, às 11:00')))
# '\ d+' denota caracteres numéricos ou grupo de caracteres
# Dividindo ocorre em '20', '1989', '11', '00'
impressão (re.Split ('\ d+', 'nascido em 20 de julho de 1989, às 11:00')))
# O máximo especificado dividido como 1
impressão (re.Split ('\ d+', 'nascido em 20 de julho de 1989, às 11:00
Am ', maxsplit = 1))

ré.sub():

Aqui o 'sub' significado é uma substring. Nesta função, a expressão regular fornecida (parâmetro padrão) é correspondente na sequência fornecida (parâmetro string); Se a substring for encontrada, ela será substituída por um parâmetro REPL.
Aqui na contagem, especifique o número de vezes que o regex é substituído.
Aqui podemos especificar a bandeira regex (ex: re. IGNORAR CASO)

Sintaxe:- re.sub (padrão, repl, string, count = 0, sinalizadores = 0)
Valor de retorno:
Retorna uma nova string depois de substituir um padrão mais
Retorna a mesma corda

Ex:

importar re
# Ex: Pattern 'lly' corresponde à string em "com sucesso" e "delly"
impressão (re.sub ('lly', '#$', 'nomeação médica reservada com sucesso em delly')))
# Ex: case hasbeen ignorou, usando sinalizador, 'lly' combinará duas vezes com a string
# Após a correspondência, 'Lly' é substituído por '~*' em "com sucesso" e "Delly".
impressão (re.sub ('lly', '#$', 'nomeação de doutor reservada com sucesso em delly', bandeiras = re.IGNORAR CASO))
# Ex: Case sentivity, 'lly' não será reaplicado.
impressão (re.sub ('lly', '#$', 'nomeação médica reservada com sucesso em delly')))
# Ex: como contagem = 1, a substituição máxima dos tempos ocorre é 1
impressão (re.sub ('lly', '#$', 'nomeação de doutor reservada com sucesso em delly', count = 1, sinalizador = re.IGNORAR CASO))

ré.subn ():

funcionalidade subn () igual a sub () de todas as maneiras; A única diferença é fornecer saída. Ele retorna uma tupla que contém uma contagem de um total de substituição e a nova string.
Sintaxe:- re.subn (padrão, repl, string, count = 0, sinalizadores = 0)

Ex:

importar re
impressão (re.subn ('lly', '#$', 'nomeação de doutor reservada com sucesso em delly')))
t = re.subn ('lly', '#$', 'nomeação de doutor reservada com sucesso em delly', bandeiras = re.IGNORAR CASO)
impressão (t)
Imprimir (Len (t))
# Isso dará a mesma saída que sub ()
Imprimir (t [0])

ré.escapar() :

Isso retorna string com barragem '\' antes de cada personagem não alfanumérico. Isso é útil se quisermos combinar uma corda literal arbitrária que possa ter uma expressão regular metacaracters.
Sintaxe:- re.Escape (string)
Ex:

importar re
# abaixo do caso tem apenas ", não é alfanumérico
impressão (re.Escape ("Nomeação médica reservada com sucesso às 13h")))
# abaixo do caso tem ", caret '^', '-', '[]', '\' não são alfanuméricos
impressão (re.Escape ("Ele perguntou o que é isso [0-9], eu disse \ t ^classe numérica")))

Conclusão:

O artigo abrangeu as coisas necessárias para entender a expressão regular em qualquer aplicação. Aprendemos vários métodos e meta -caracteres presentes no Python Regexp usando exemplos.