Expresiones regulares (RegEx) en Python

In questo tutorial, imparerai l'espressione regolare (RegEx) e come utilizzarla insieme al modulo re di Python (con l'aiuto di esempi).

L'espressione regolare (RegEx) è una sequenza di caratteri che definisce un modello di ricerca. Ad esempio, }}

^a...s$

Il codice sopra definisce il modello RegEx. Il modello è:conache inizia consche termina conQualsiasi stringa di cinque lettere。

I modelli definiti con RegEx possono essere utilizzati per corrispondere con le stringhe.

Python ha un modulo chiamato reRegEx. Ecco un esempio:

import　re
pattern　=　'^a...s$'
test_string　=　'abyss'
result　=　re.match(pattern,　test_string)
if　result:
　　print("Ricerca riuscita.")
else:
　　print("Ricerca non riuscita.")

Qui, usiamo la funzione re.match() per cercare un modello nella stringa di test. Se la ricerca ha successo, questo metodo restituirà un oggetto di corrispondenza. In caso contrario, restituirà None.

reLe funzioni definite nel modulo sono altre che possono essere utilizzate con RegEx. Prima di esplorarle, diamo un'occhiata all'espressione regolare stessa.

Se hai già familiarità con le basi di RegEx, puoi saltare aPython RegEx。

Specificare un modello utilizzando l'espressione regolare

Per specificare un'espressione regolare, si utilizzano i caratteri jolly. Nei esempi precedenti, ^ e $ sono caratteri jolly.

Caratteri jolly

I caratteri jolly sono interpretati in modo speciale dal motore di RegEx. Ecco l'elenco dei caratteri jolly:

[]　. ^ $ * +　? {}　() \ |

[] - parentesi quadrate

Le parentesi quadrate specificano il gruppo di caratteri da corrispondere.

Qui, [abc] corrisponderà, se vuoi corrispondere una stringa che contiene qualsiasi a, b o c.

Puoi anche usare - per specificare un intervallo di caratteri all'interno degli apici.

• [a-e] è lo stesso di [abcde].

• [1-4] è lo stesso di [1234].

• [0-39] è lo stesso di [01239].

Puoi anche usare ^ all'inizio degli apici per completare (inversione) un set di caratteri.

• [^abc] rappresenta tutto trannea或b或cal di fuoridiQualsiasi carattere.

• [^0-9] rappresenta qualsiasi carattere non numerico.

.- Punto

Il punto corrisponde a qualsiasi singolo carattere (eccetto il carattere di newline '\n').

^- Simbolo di inserimento

Il simbolo di inserimento ^ serve per verificare se una stringa inizia con un carattere specifico.

$- Simbolo di dollaro

Il simbolo di dollaro $ viene utilizzato per verificare se la stringaconun carattere specificofine。

*- Simbolo di asterisco

Il simbolo di asterisco * corrispondeZero o più voltedel modello rimanente.

+- Simbolo di somma

Il simbolo di somma + corrispondeUna o più voltedel modello rimanente.

?- Simbolo di domanda

Il simbolo di domanda ? corrispondeApare zero o una voltadel modello rimanente.

{}- Parentesi graffe

Parentesi graffe {n,m}.n stili. Questo significa che devono essere conservatistili, e al massimo ripetutim stilistili.

Proviamo un altro esempio. Il RegEx [0-9]{2, 4} corrisponde a una stringa che contiene almeno 2 ma non più di 4 cifre

|- Barra verticale

La barra verticale | viene utilizzata per esprimere l'operazione logica di alternanza (operatore or).

In questo caso, a|b corrisponde a qualsiasi stringa che contienea或del字符串

()- Parentesi

Le parentesi () vengono utilizzate per raggruppare sotto-modelli. Ad esempio, (a|b|c)xz corrisponde a qualsiasi stringa che contienea或b或ccorrisponde e seguedel字符串

\- Barra obliqua inversa

La barra obliqua inversa \ viene utilizzata per escapare vari caratteri, inclusi i meta-caratteri. Ad esempio,

\$a se la stringa contiene $ seguita da a, la corrispondenza avviene. In questo caso, il motore RegEx non lo interpreta in modo speciale.

Se non si è sicuri che un carattere abbia un significato speciale, si può metterlo davanti a \ per assicurarsi che non venga trattato in modo speciale.

Sequenze speciali

Le sequenze speciali rendono più facile scrivere modelli comuni. Ecco una lista delle sequenze speciali:

\A -se il carattere specificato è all'inizio della stringa, la corrispondenza avviene.

\b -se abilita la corrispondenza se il carattere specificato è all'inizio o alla fine della parola.

\B-与\b。如果指定的字符不在单词的开头或结尾，则匹配。

\d-匹配任何十进制数字。相当于[0-9]

\D-匹配任何非十进制数字。相当于[^0-9]

\s-匹配字符串包含任何空格字符的地方。等同于[ \t\n\r\f\v]。

\S-匹配字符串包含任何非空白字符的地方。等同于[^ \t\n\r\f\v]。

\w-匹配任何字母数字字符（数字和字母）。等同于[a-zA-Z0-9_]。顺便说一下，下划线_也被认为是字母数字字符。

\W-匹配任何非字母数字字符。相当于[^a-zA-Z0-9_]

\Z -如果指定的字符在字符串的末尾，则匹配。

提示：要构建和测试正则表达式，可以使用RegEx测试器工具，例如regex。该工具不仅可以帮助您创建正则表达式，还可以帮助您学习它。

现在，您了解了RegEx的基础知识，让我们讨论如何在Python代码中使用RegEx。

Python正则表达式

Python有一个名为re正则表达式的模块。要使用它，我们需要导入模块。

import　re

该模块定义了一些可与RegEx一起使用的函数和常量。

re.findall()

re.findall()方法返回包含所有匹配项的字符串列表。

示例1：re.findall()

# 从字符串中提取数字的程序
import　re
string = 'hello 12 hi 89. Howdy 34'
pattern = '\d+'
result = re.findall(pattern, string)　
print(result)
#　Output:　['12', '89', '34']

Se non si trova il modello, re.findall() restituisce una lista vuota.

re.split()

Il metodo split suddivide la stringa corrispondente alle occorrenze e restituisce una lista delle stringhe suddivise.

Esempio 2: re.split()

import　re
string = 'Twelve:12 Eighty nine:89.'
pattern = '\d+'
result = re.split(pattern, string)　
print(result)
#　Output:　['Twelve:', 'Eighty nine:', '.']

Se non si trova il modello, re.split() restituisce una lista contenente stringhe vuote.

Puoi passare il parametro maxsplit al metodo re.split(). Questo è il numero massimo di divisioni che avverranno.

import　re
string = 'Twelve:12 Eighty nine:89 Nine:9.'
pattern = '\d+'
#　maxsplit = 1
#　Split only at the first occurrence
result = re.split(pattern, string, 1)　
print(result)
#　Output:　['Twelve:', 'Eighty nine:89 Nine:9.']

A proposito, il valore predefinito di maxsplit è 0; il valore predefinito è 0. Questo significa che tutte le occorrenze trovate vengono suddivise.

re.sub()

Sintassi di re.sub():

re.sub(pattern, replace, string)

Questo metodo restituisce una stringa nella quale le occorrenze corrispondenti vengono sostituite con il contenuto della variabile replace.

Esempio 3: re.sub()

# Programma per rimuovere tutti gli spazi
import　re
# Stringa multiriga
string = 'abc 12\
de 23 
 f45 6'
# Corrisponde a tutti i caratteri di spazio
pattern = '\s+'
# Stringa vuota
replace = ''
new_string = re.sub(pattern, replace, string)　
print(new_string)
#　Output:　abc12de23f456

Se non si trova il modello, re.sub() restituisce la stringa originale.

Puoi passarecountViene passata come quarto argomento al metodo re.sub(). Se omesso, il risultato è 0. Questo sostituirà tutte le occorrenze trovate.

import　re
# Stringa multiriga
string = 'abc 12\
de 23 
 f45 6'
# Corrisponde a tutti i caratteri di spazio
pattern = '\s+'
replace = ''
new_string = re.sub(r'\s+', replace, string, 1)　
print(new_string)
#　Output:
#　abc12de　23
#　f45　6

re.subn()

re.subn() è simile a re.sub(), si aspetta che restituisca un tuple contenente 2 elementi, uno per il nuovo stringa e uno per il numero di sostituzioni effettuate.

Esempio 4: re.subn()

# Programma per rimuovere tutti gli spazi
import　re
# Stringa multiriga
string = 'abc 12\
de 23 
 f45 6'
# Corrisponde a tutti i caratteri di spazio
pattern = '\s+'
# Stringa vuota
replace = ''
new_string = re.subn(pattern, replace, string)　
print(new_string)
# Output: ('abc12de23f456', 4)

re.search()

Il metodo re.search() accetta due parametri: il modello e la stringa. Questo metodo cerca la prima posizione di corrispondenza tra il modello RegEx e la stringa.

Se la ricerca ha successo, re.search() restituisce un oggetto di match. Altrimenti, restituisce None.

match = re.search(pattern, str)

Esempio 5: re.search()

import　re
string = "Python is fun"
# Controlla se "Python" è all'inizio
match = re.search('\APython', string)
if match:
　　print("pattern found inside the string")
else:
　　print("pattern not found")　　
# Output: pattern found inside the string

qui,matchche contiene un oggetto match.

l'oggetto di match

Puoi usaredir()La funzione ottiene i metodi e gli attributi dell'oggetto di match.

Alcuni metodi e attributi comuni dell'oggetto di match sono:

match.group()

Il metodo group() restituisce la parte corrispondente della stringa.

Esempio 6: oggetto di match

import　re
string = '39801 356, 2102 1111'
# Tre numeri, seguiti da uno spazio, e due numeri
pattern = '(\d{3}) (\d{2})'
# Il variabile match contiene un oggetto Match.
match = re.search(pattern, string)　
if match:
　　print(match.group())
else:
　　print("pattern not found")
# Output: 801 35

qui,matchLa variabile contiene un oggetto match.

Il nostro modello ha due sotto-gruppi (\d{3}) (\d{2}) e (\d{3}) e (\d{2}). Puoi ottenere una parte della stringa dei sotto-gruppi tra parentesi. Ecco come:

>>> match.group(1)
'801'
>>> match.group(2)
'35'
>>> match.group(1, 2)
('801', '35')
>>> match.groups()
('801', '35')

match.start()，match.end()和match.span()

start()函数返回匹配的子字符串的开头的索引。同样，end()返回匹配的子字符串的结束索引。

>>> match.start()
2
>>> match.end()
8

span()函数返回一个包含匹配部分的开始和结束索引的元组。

>>> match.span()
(2, 8)

match.re和match.string

匹配对象的re属性返回一个正则表达式对象。 同样，string属性返回传递的字符串。

>>> match.re
re.compile('(\\d{3})  (\\d{2})')
>>> match.string
'39801 356, 2102 1111'

我们已经介绍了re模块中定义的所有常用方法。如果您想了解更多信息，请访问Python 3 re模块。

在RegEx之前使用r前缀

如果在正则表达式之前使用r或R前缀，则表示原始字符串。例如，'\n'是一个新行，而r'\n'表示两个字符：反斜杠\后跟n。

反斜杠\用于转义包括所有元字符在内的各种字符。但是，使用r前缀\会将其视为普通字符。

示例7：使用r前缀的原始字符串

import　re
string　=　'\n　and　\r　are　escape　sequences.'
result　=　re.findall(r'[\n\r]',　string)　
print(result)
#　输出:　['\n',　'\r']