Combinação de conhecimento de expressão regular do Python

1. Sintaxe da expressão regular

1.1 Personagens e classes de personagens

(1) Caracteres especiais: \ .^ $ ? + * { } [ ] ( ) |

Se os caracteres especiais acima quiserem usar valores literais, eles devem ser escapados com \

(2) Classe de personagem

• Um ou mais caracteres contidos em [] são chamados de classe de caracteres e, se uma classe de caracteres não especificar um quantificador durante a correspondência, apenas um deles será correspondido.
• Um intervalo pode ser especificado em uma classe de caracteres, como [a-zA-Z0-9], que significa qualquer caractere entre a a z, A a Z e 0 a 9.
• Um colchete esquerdo seguido por um ^{significa negar uma classe de caractere, como [} 0-9], significa corresponder a qualquer caractere não numérico.
• Dentro da classe de caracteres, exceto \, outros caracteres especiais não possuem mais significados especiais e todos representam valores literais. Prompt, ^{colocá-lo na primeira posição significa negação, colocá-lo em outras posições significa} ele mesmo, - colocá-lo no meio significa intervalo, colocá-lo no primeiro caractere na classe de caractere significa - ele mesmo.
• Abreviações como \d \s \w podem ser usadas dentro de classes de caracteres.

(3) Método abreviado

• corresponde a qualquer caractere, exceto uma nova linha, ou se o sinalizador re.DOTALL estiver presente, corresponde a qualquer caractere, incluindo uma nova linha.
• \d corresponde a um número Unicode, se for com re.ASCII, corresponde a 0-9.
• \D corresponde a não dígitos Unicode.
• \s corresponde ao espaço em branco Unicode, ou um dos \t\n\r\f\v se com re.ASCII.
• \S corresponde a Unicode sem espaços em branco.
• \w corresponde a um caractere de palavra Unicode, ou um de [a-zA-Z0-9_] se com re.ASCII.
• \W corresponde a caracteres Unicode que não são palavras.

1.2 Quantificadores

• • Corresponde ao caractere anterior 0 ou 1 vez.
• * corresponde ao caractere anterior 0 ou mais vezes.
• + Corresponde ao caractere anterior 1 ou mais vezes.
• {m} corresponde à expressão anterior m vezes.
• {m,} corresponde à expressão anterior pelo menos m vezes.
• {,n} corresponde à expressão regular anterior até n vezes.
• {m,n} corresponde à expressão regular anterior pelo menos m e no máximo n vezes.

1.3 Preguiça e Ganância

Os quantificadores acima são todos modos gulosos, que corresponderão ao maior número possível. Se você quiser mudar para um modo não guloso, poderá implementá-lo seguindo o quantificador com um ?, que é definido como correspondência preguiçosa.

1.4 Grupo e Captura

(1) A função de ():

Capture o conteúdo da expressão regular em () para processamento posterior. Você pode desativar a função de captura deste colchete seguindo o colchete de abertura com ?:.

Combine partes de expressões regulares para usar quantificadores ou |.

(2) O eco faz referência ao conteúdo capturado no ():

Referências anteriores por número:

A cada parêntese que não utilizar ?: será atribuído um número, começando de 1 e aumentando da esquerda para a direita.Você pode usar \i para se referir ao conteúdo capturado pela expressão no anterior ().

Faça referência ao conteúdo capturado nos parênteses anteriores pelo nome do grupo:

Um grupo pode ser alias seguindo o colchete de abertura com ?P, colocando o nome entre colchetes angulares, seguido por (?P=nome) para se referir ao conteúdo capturado anteriormente. Tal como (? P\w+)\s+(?P=palavra) para corresponder a palavras repetidas.

(3) Observação:

Referências anteriores não podem ser usadas em classes de caracteres [].

1.5 Asserções e bandeiras

As asserções não correspondem a nenhum texto, apenas impõem certas restrições ao texto no qual a asserção é feita.

(1) Afirmações comuns:

• \b corresponde ao limite de uma palavra e a coloca na classe de caractere [] para representar backspace.
• \B corresponde a um limite não-palavra, sujeito à marcação ASCII.
• \A corresponde ao início.
• ^ corresponde no início ou após cada nova linha se o sinalizador MULTILINE estiver presente.
• \Z corresponde ao final.
• $ corresponde ao final e, se o sinalizador MULTILINE estiver presente, antes de cada nova linha.
• (?=e) Antecipação positiva.
• (?!e) Antecipação negativa.
• (?<=e) está olhando para trás.
• (?<!e) Lookback negativo.

(2) Explicação de previsões e retrospectivas

• Olhe para frente: exp1(?=exp2) O conteúdo por trás de exp1 deve corresponder a exp2
• Negative lookahead: exp1(?!exp2) O conteúdo após exp1 não pode corresponder a exp2
• Olhando para trás: (?<=exp2)exp1 O conteúdo na frente de exp1 deve corresponder a exp2
• Lookbehind negativo: (?<!exp2)exp1 O conteúdo antes de exp1 não pode corresponder a exp2

Por exemplo: para encontrar hello, mas hello deve ser seguido por world, a expressão regular pode ser escrita assim: "(hello)\s+(?=world)", usada para corresponder a "hello wangxing" e "hello world", etc., mas corresponde apenas a olá.

1.6 Correspondência de condições

(?(id)yes_exp|no_exp): Se a subexpressão correspondente a id corresponder ao conteúdo, então corresponda yes_exp aqui, caso contrário, corresponda a no_exp.

1.7 Sinalizadores para expressões regulares

(1) Existem duas maneiras de usar os sinalizadores de expressões regulares:

• Ao passar os parâmetros do sinalizador para o método compile(), vários sinalizadores podem ser separados por |, como re.compile(r"#[\da-f]{6}\b", re.IGNORECASE|re.MULTILINE).
• Adicione sinalizadores à expressão regular adicionando (? sinalizador) na frente da expressão regular, como (?ms)#[\da-z]{6}\b.

sinais comumente usados

• re.A ou re.ASCII, faça com que \b \B \s \S \w \W \d \D todos suponham que a string seja ASCII.
• re.I ou re.IGNORECASE Transforma a expressão regular em maiúsculas e minúsculas.
• re.M ou re.MULTILINE Correspondência de várias linhas, de modo que cada ^ corresponda após cada retorno de carro e cada $ corresponda antes de cada retorno de carro.
• re.S ou re.DOTALL ativar. Pode corresponder a qualquer caractere, incluindo retorno de linha.
• re.X ou re.VERBOSE Desta forma, a expressão regular pode abranger várias linhas e comentários também podem ser adicionados, mas os espaços em branco precisam ser representados por \s ou [ ], porque os espaços em branco padrão não são mais interpretados. como:

re.compile(r"""
<img\s  +)   #标签的开始
[^>]*?       #不是src的属性
src=         #src属性的开始
(?:
(?P<quote>["'])                #左引号
(?P<image_name>[^\1>]+?)  #图片名字
(?P=quote)                     #右括号
""",re.VERBOSE|re.IGNORECASE)

2. Módulo de expressão regular

2.1 Existem quatro funções principais de strings de processamento de expressões regulares

• Match verifica se uma string está de acordo com a sintaxe de uma expressão regular e geralmente retorna true ou false.
• Obtenha a expressão regular para extrair o texto necessário na string.
• Substituir encontra o texto em uma string que corresponde a uma expressão regular e o substitui pela string correspondente.
• Split usa expressões regulares para dividir strings.

2.2 Duas maneiras de os módulos usarem expressões regulares

• Use o método re.compile(r, f) para gerar um objeto de expressão regular e, em seguida, chame o método correspondente do objeto de expressão regular. A vantagem dessa abordagem é que os objetos regulares podem ser usados ​​várias vezes após serem gerados.
• Cada método de objeto do objeto de expressão regular no módulo re tem um método de módulo correspondente, a única diferença é que o primeiro parâmetro passado é uma string de expressão regular. Essa abordagem é adequada para expressões regulares usadas apenas uma vez.

2.3 Métodos comuns de objetos de expressão regular

(1) rx.findall(s,início, fim):

Retorna uma lista. Se não houver agrupamento na expressão regular, a lista contém todo o conteúdo correspondente. Se houver um agrupamento na expressão regular, cada elemento na lista é uma tupla e a tupla contém subgrupos Conteúdo correspondente, mas não não retorna o conteúdo correspondente à expressão regular inteira.

(2) rx.finditer(s, start, end):

Retorna um objeto iterável.

Itere sobre o objeto iterável e retorne um objeto correspondente a cada vez. Você pode chamar o método group() do objeto correspondente para visualizar o conteúdo correspondente ao grupo especificado. 0 significa o conteúdo correspondente à expressão regular inteira.

(3) rx.search(s, início, fim):

Retorna um objeto de correspondência ou None se nenhuma correspondência for encontrada.

O método de pesquisa corresponde apenas uma vez e depois para, e não continuará a corresponder mais tarde.

(4) rx.match(s, start, end):

Retorna um objeto de correspondência se a expressão regular corresponder ao início da string, caso contrário, retorna None.

(5) rx.sub(x, s, m):

Retorna uma string. Cada lugar correspondente é substituído por x, e a string substituída é retornada.Se m for especificado, ele será substituído até m vezes. Para x, você pode usar /i ou /gid pode ser um nome ou número de grupo para se referir ao conteúdo capturado.

Uma função está disponível para x no método do módulo re.sub(r, x, s, m) . Neste ponto, podemos enviar o conteúdo capturado por meio desta função para processamento e, em seguida, substituir o texto correspondente.

(6) rx.subn(x, s, m):

Igual ao método re.sub(), a diferença é que ele retorna duas tuplas, uma das quais é a string de resultado e a outra é o número de substituições.

(7) rx.split(s, m): string dividida

Retorna uma lista.

Divida a string com o conteúdo correspondente à expressão regular.

Se houver um grupo na expressão regular, coloque o conteúdo correspondente ao grupo no meio de cada duas divisões na lista como parte da lista, como:

import re
rx =  re.compile(r"(\d)[a-z]+(\d)")
s =  "ab12dk3klj8jk9jks5"
result =  rx.split(s)
print(result)
#返回['ab1',  '2', '3', 'klj', '8', '9', 'jks5']

(8) rx.flags(): Flags definidos ao compilar expressões regulares

(9) rx.pattern(): A string usada ao compilar a expressão regular.

(10) m.grupo(g, …)

Retorna o conteúdo correspondente ao número ou nome do grupo. O padrão ou 0 significa o conteúdo correspondente à expressão inteira. Se mais de um for especificado, uma tupla será retornada.

(11) m.groupdict(padrão)

Devolva um dicionário. As chaves do dicionário são os nomes de grupo de todos os grupos nomeados e os valores são os que o grupo nomeado captura.

Se houver um parâmetro padrão, ele será usado como valor padrão para os grupos que não participaram da partida.

(12) m.groups(padrão)

Retorna uma tupla. Contém todos os subgrupos que capturam conteúdo, começando em 1. Se um valor padrão for especificado, esse valor será usado como o valor daqueles grupos que não capturam conteúdo.

(13) m.últimogrupo()

O nome do grupo de captura de número mais alto que correspondeu ao conteúdo, ou Nenhum (não comumente usado) se nenhum ou nenhum nome for usado.

(14) m.lastindex()

O número do grupo de captura de número mais alto que correspondeu ao conteúdo ou Nenhum, se nenhum.

(15) m.start(g):

O subgrupo do objeto correspondente atual é correspondido a partir dessa posição da string e -1 é retornado se o grupo atual não participar da correspondência.

(16) m.fim(g)

O subgrupo do objeto correspondente atual é correspondido a partir dessa posição da string. Se o grupo atual não participar da correspondência, -1 será retornado.

(17) m.span()

Retorne uma tupla de 2, o conteúdo são os valores de retorno de m.start(g) e m.end(g) respectivamente.

(18) m.re()

A expressão regular que produz esse objeto de correspondência.

(19) m.string()

A cadeia de caracteres passada para correspondência ou pesquisa de correspondência.

(20) m.pos()

A posição inicial da pesquisa. Ou seja, o início da string ou a posição especificada por start (não comumente usado).

(21) m.endpos()

A posição final da pesquisa. Ou seja, a posição final da string ou a posição especificada por end (não comumente usada).

2.4 Resumo

• Para a função de correspondência de expressões regulares, o Python não tem um método para retornar verdadeiro e falso, mas pode ser julgado se o valor de retorno da correspondência ou do método de pesquisa é Nenhum.
• Para a função de pesquisa de expressões regulares, se você pesquisar apenas uma vez, poderá usar o objeto correspondente retornado pelo método search ou match para obtê-lo. Para várias pesquisas, você pode usar o objeto iterável retornado pelo método finditer para acessar iterativamente.
• Para a função de substituição de expressão regular, você pode usar o método sub ou subn do objeto de expressão regular ou pode usar o método sub ou subn do módulo re. A diferença é que o texto de substituição do método sub do módulo pode ser gerado usando uma função.
• Para a função de divisão de expressão regular, você pode usar o método split do objeto de expressão regular. Observe que se o objeto de expressão regular tiver agrupamento, o conteúdo capturado pelo agrupamento também será colocado na lista retornada.

Anexo: O significado dos caracteres comumente usados ​​em expressões regulares

A própria expressão regular é uma linguagem de programação pequena e altamente especializada e, em Python, ao incorporar e integrar o módulo re, ela pode ser chamada diretamente para obter correspondência regular. Padrões de expressões regulares são compilados em uma série de bytecodes, que são executados por um mecanismo de correspondência escrito em C.

1. Caracteres comuns e 11 metacaracteres

Caracteres especiais	ilustrar	expressão	resultado correspondente
.	Corresponde a qualquer caractere, exceto o caractere de nova linha "\n", também pode corresponder ao caractere de nova linha no modo DOTALL	ac	abc
\	Caracteres de escape, para que o último caractere altere o significado original	ac;a\c	ac;a\c
*	Corresponde ao caractere anterior 0 ou mais vezes	abc*	ab;abccc
+	Combine o personagem anterior 1 ou ilimitadas vezes	abc+	abc;abccc
?	Corresponde a um caractere 0 ou 1 vez	abc?	ab;abc
^	Corresponde ao início de uma string. corresponder ao início de cada linha no modo multilinha	^abc	abc
$	Corresponde ao final de uma string ou ao final de cada linha no modo multilinha	abc $	abc
|	ou. Corresponde | a qualquer uma das expressões esquerda e direita, corresponde da esquerda para a direita, se | não estiver incluído em (), seu escopo é toda a expressão regular	abc | def	abc;def
{}	{m} corresponde ao caractere anterior m vezes, {m,n} corresponde ao caractere anterior m a n vezes, se n for omitido, corresponde m a infinitas vezes	ab{1,2}c	abc;abbc
[]	conjunto de caracteres. O caractere correspondente pode ser qualquer caractere no conjunto de caracteres. Os caracteres no conjunto de caracteres podem ser listados um a um ou um intervalo pode ser fornecido, como [abc] ou [ac]. [^abc] significa negação, ou seja, não abc. Observe que todos os caracteres especiais perdem seu significado especial original no conjunto de caracteres. Escapar com uma \ barra invertida restaura o significado especial dos caracteres especiais.	a[bcd]e	abe;ace;ade
()	A expressão incluída será considerada como um grupo, começando do lado esquerdo da expressão, toda vez que um parêntese esquerdo "(" de um grupo for encontrado, o número +1. A expressão do grupo como um todo pode ser seguida de quantificadores. O | na expressão só é válido neste grupo.	(abc){2};a(123|456)c	abcabc; a456c

Observe o efeito da barra invertida \:

• Barras invertidas seguidas de metacaracteres removem recursos especiais (ou seja, escape de caracteres especiais para caracteres normais).
• Uma barra invertida seguida por um caractere comum implementa uma função especial (ou seja, um caractere predefinido).
• Faça referência à cadeia de caracteres correspondente ao grupo de palavras correspondente ao número de série.

import re
a=re.search(r'(tina)(fei)haha\2','tinafeihahafei tinafeihahatina').group()
print(a)
# 结果：
# tinafeihahafei

2. Conjunto de caracteres predefinidos (pode ser escrito em conjunto de caracteres[...])

Caracteres especiais	ilustrar	expressão	resultado correspondente
\d	Número: [0-9]	abc	a1c
\D	Não é um número:[^\d]	para\Dc	abc
\s	Corresponde a qualquer caractere de espaço em branco: [<espaço>\t\r\n\f\v]	a\sc	ac
\S	Caracteres não em branco:[^\s]	a\Sc	abc
\c	Corresponde a qualquer caractere, incluindo sublinhado: [A-Za-z0-9_]	a\wc	abc
\C	Corresponde a caracteres não alfabéticos, ou seja, corresponde a caracteres especiais	a\Wc	ac
\A	Corresponde apenas ao início da string, igual a ^	\Aabc	abc
\Z	Corresponde apenas ao final da string, igual a $	abc\Z	abc
\b	Corresponde entre \w e \W, ou seja, corresponde ao limite da palavra, ou seja, a posição entre a palavra e o espaço. Por exemplo, 'er\b' corresponde a 'er' em "nunca", mas não a 'er' em "verbo".	\babc\b; a\b!bc	espaço abc espaço; a!bc
\B	Correspondência sem limite: [^\b]	a\Bbc	abc

import re
w = re.findall('\btina','tian tinaaaa')
print(w)
s = re.findall(r'\btina','tian tinaaaa')
print(s)
v = re.findall(r'\btina','tian#tinaaaa')
print(v)
a = re.findall(r'\btina\b','tian#tina@aaa')
print(a)
'''执行结果如下：
[]
['tina']
['tina']
['tina']'''

código de teste

3. Uso de grupo especial

Caracteres especiais	ilustrar	expressão	resultado correspondente
(?P)	Grupo, especifique um alias adicional além do número original	(?Pabc){2}	abc abc
(?P=nome)	Citando o grupo com o alias para corresponder à string	(?P\d)abc(?P=id)	1abc1; 5abc5
<número>	Grupos com números de referência correspondentes à string	(\d)abc\1	1abc1; 5abc5