Python - Espressioni regolari

Un'espressione regolare è una sequenza di caratteri speciale che consente di abbinare o trovare altre stringhe o insiemi di stringhe, utilizzando una sintassi specializzata, impartita in un modello. Le espressioni regolari sono ampiamente utilizzate nel mondo UNIX.

Il modulo Python refornisce il supporto completo per le espressioni regolari simili a Perl in Python. Il modulo re solleva l'eccezione re.error se si verifica un errore durante la compilazione o l'utilizzo di un'espressione regolare.

Copriremo due importanti funzioni, che sarebbero usate per gestire le espressioni regolari. Ma prima una piccola cosa: ci sono vari caratteri, che avrebbero un significato speciale quando vengono usati nelle espressioni regolari. Per evitare qualsiasi confusione quando si ha a che fare con le espressioni regolari, useremmo Raw Strings comer'expression'.

La funzione match

Questa funzione tenta di abbinare il pattern RE alla stringa con flag opzionali .

Ecco la sintassi per questa funzione:

re.match(pattern, string, flags=0)

Ecco la descrizione dei parametri:

Sr.No. Parametro e descrizione
1

pattern

Questa è l'espressione regolare da abbinare.
2

string

Questa è la stringa, che dovrebbe essere cercata in modo che corrisponda al modello all'inizio della stringa.
3

flags

È possibile specificare flag diversi utilizzando OR bit per bit (|). Questi sono modificatori, elencati nella tabella seguente.

La funzione re.match restituisce un filematch oggetto di successo, Nonein caso di fallimento. Usiamo la funzione group (num) o groups () dimatch oggetto per ottenere l'espressione corrispondente.

Sr.No. Metodo e descrizione dell'oggetto della corrispondenza
1

group(num=0)

Questo metodo restituisce l'intera corrispondenza (o il numero di sottogruppo specifico)
2

groups()

Questo metodo restituisce tutti i sottogruppi corrispondenti in una tupla (vuoto se non ce n'erano)

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

La funzione di ricerca

Questa funzione cerca la prima occorrenza del pattern RE all'interno di una stringa con flag opzionali .

Ecco la sintassi per questa funzione:

re.search(pattern, string, flags=0)

Ecco la descrizione dei parametri:

Sr.No. Parametro e descrizione
1

pattern

Questa è l'espressione regolare da abbinare.
2

string

Questa è la stringa, che dovrebbe essere cercata in modo che corrisponda al modello in qualsiasi punto della stringa.
3

flags

È possibile specificare flag diversi utilizzando OR bit per bit (|). Questi sono modificatori, elencati nella tabella seguente.

La funzione re.search restituisce un filematch oggetto di successo, nonein caso di fallimento. Usiamo la funzione group (num) o groups () dimatch oggetto per ottenere l'espressione corrispondente.

Sr.No. Corrispondenza metodi oggetto e descrizione
1

group(num=0)

Questo metodo restituisce l'intera corrispondenza (o il numero di sottogruppo specifico)
2

groups()

Questo metodo restituisce tutti i sottogruppi corrispondenti in una tupla (vuoto se non ce n'erano)

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

Confronto tra ricerca e corrispondenza

Python offre due diverse operazioni primitive basate su espressioni regolari: match verifica la presenza di una corrispondenza solo all'inizio della stringa, mentre search verifica la presenza di una corrispondenza ovunque nella stringa (questo è ciò che Perl fa di default).

Esempio

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

No match!!
search --> searchObj.group() :  dogs

Cerca e sostituisci

Uno dei più importanti re metodi che utilizzano espressioni regolari è sub.

Sintassi

re.sub(pattern, repl, string, max=0)

Questo metodo sostituisce tutte le occorrenze del modello RE nella stringa con repl , sostituendo tutte le occorrenze a meno che non venga fornito max . Questo metodo restituisce una stringa modificata.

Esempio

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Quando il codice sopra viene eseguito, produce il seguente risultato:

Phone Num :  2004-959-559
Phone Num :  2004959559

Modificatori di espressioni regolari: flag di opzione

I letterali delle espressioni regolari possono includere un modificatore opzionale per controllare vari aspetti della corrispondenza. I modificatori sono specificati come flag opzionale. Puoi fornire più modificatori utilizzando OR esclusivo (|), come mostrato in precedenza e può essere rappresentato da uno di questi -

Sr.No. Modificatore e descrizione
1

re.I

Esegue la corrispondenza senza distinzione tra maiuscole e minuscole.
2

re.L

Interpreta le parole in base alla locale corrente. Questa interpretazione influisce sul gruppo alfabetico (\ w e \ W), così come sul comportamento dei confini delle parole (\ be \ B).
3

re.M

Fa corrispondere $ alla fine di una riga (non solo alla fine della stringa) e fa corrispondere ^ l'inizio di qualsiasi riga (non solo l'inizio della stringa).
4

re.S

Fa corrispondere un punto (punto) a qualsiasi carattere, inclusa una nuova riga.
5

re.U

Interpreta le lettere in base al set di caratteri Unicode. Questo flag influenza il comportamento di \ w, \ W, \ b, \ B.
6

re.X

Consente la sintassi delle espressioni regolari "più carina". Ignora gli spazi (eccetto all'interno di un insieme [] o quando è preceduto da una barra rovesciata) e tratta # senza caratteri di escape come un marcatore di commento.

Modelli di espressioni regolari

Fatta eccezione per i personaggi di controllo, (+ ? . * ^ $ ( ) [ ] { } | \), tutti i personaggi corrispondono a se stessi. È possibile eseguire l'escape di un carattere di controllo precedendolo con una barra rovesciata.

La tabella seguente elenca la sintassi delle espressioni regolari disponibile in Python:

Sr.No. Modello e descrizione
1

^

Corrisponde all'inizio della riga.
2

$

Corrisponde alla fine della riga.
3

.

Corrisponde a qualsiasi carattere singolo tranne la nuova riga. L'uso dell'opzione m consente anche di abbinare la nuova riga.
4

[...]

Corrisponde a qualsiasi singolo carattere tra parentesi.
5

[^...]

Corrisponde a qualsiasi carattere singolo non tra parentesi
6

re*

Corrisponde a 0 o più occorrenze dell'espressione precedente.
7

re+

Corrisponde a 1 o più occorrenze dell'espressione precedente.
8

re?

Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
9

re{ n}

Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
10

re{ n,}

Corrisponde a n o più occorrenze dell'espressione precedente.
11

re{ n, m}

Corrisponde ad almeno n e al massimo m occorrenze dell'espressione precedente.
12

a| b

Corrisponde a a o b.
13

(re)

Raggruppa le espressioni regolari e ricorda il testo corrispondente.
14

(?imx)

Attiva temporaneamente le opzioni i, m o x all'interno di un'espressione regolare. Se tra parentesi, viene interessata solo quell'area.
15

(?-imx)

Disattiva temporaneamente le opzioni i, m o x all'interno di un'espressione regolare. Se tra parentesi, viene interessata solo quell'area.
16

(?: re)

Raggruppa le espressioni regolari senza ricordare il testo corrispondente.
17

(?imx: re)

Attiva temporaneamente le opzioni i, m o x tra parentesi.
18

(?-imx: re)

Disattiva temporaneamente le opzioni i, m o x tra parentesi.
19

(?#...)

Commento.
20

(?= re)

Specifica la posizione utilizzando un modello. Non ha una gamma.
21

(?! re)

Specifica la posizione utilizzando la negazione del modello. Non ha una gamma.
22

(?> re)

Corrisponde a pattern indipendenti senza backtracking.
23

\w

Corrisponde ai caratteri delle parole.
24

\W

Corrisponde a caratteri non di parole.
25

\s

Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
26

\S

Corrisponde a spazi non bianchi.
27

\d

Corrisponde alle cifre. Equivalente a [0-9].
28

\D

Corrisponde a non cifre.
29

\A

Corrisponde all'inizio della stringa.
30

\Z

Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
31

\z

Corrisponde alla fine della stringa.
32

\G

Punto delle partite in cui è finita l'ultima partita.
33

\b

Corrisponde ai confini delle parole quando sono al di fuori delle parentesi. Corrisponde a backspace (0x08) quando è racchiuso tra parentesi.
34

\B

Corrisponde ai confini non di parole.
35

\n, \t, etc.

Trova nuove righe, ritorni a capo, tabulazioni, ecc.
36

\1...\9

Corrisponde all'ennesima sottoespressione raggruppata.
37

\10

Corrisponde all'ennesima sottoespressione raggruppata se corrisponde già. Altrimenti si riferisce alla rappresentazione ottale di un codice carattere.

Esempi di espressioni regolari

Personaggi letterali

Sr.No. Esempio e descrizione
1

python

Trova "python".

Classi di personaggi

Sr.No. Esempio e descrizione
1

[Pp]ython

Abbina "Python" o "Python"
2

rub[ye]

Trova "ruby" o "rube"
3

[aeiou]

Trova una vocale qualsiasi minuscola
4

[0-9]

Trova qualsiasi cifra; uguale a [0123456789]
5

[a-z]

Trova qualsiasi lettera ASCII minuscola
6

[A-Z]

Trova qualsiasi lettera ASCII maiuscola
7

[a-zA-Z0-9]

Abbina uno dei precedenti
8

[^aeiou]

Trova qualsiasi cosa diversa da una vocale minuscola
9

[^0-9]

Trova qualsiasi cosa diversa da una cifra

Classi di caratteri speciali

Sr.No. Esempio e descrizione
1

.

Trova qualsiasi carattere tranne la nuova riga
2

\d

Trova una cifra: [0-9]
3

\D

Trova una non cifra: [^ 0-9]
4

\s

Trova uno spazio vuoto: [\ t \ r \ n \ f]
5

\S

Trova spazio non bianco: [^ \ t \ r \ n \ f]
6

\w

Trova il carattere di una sola parola: [A-Za-z0-9_]
7

\W

Trova un carattere diverso da una parola: [^ A-Za-z0-9_]

Casi di ripetizione

Sr.No. Esempio e descrizione
1

ruby?

Trova "rub" o "ruby": la y è facoltativa
2

ruby*

Trova "strofina" più 0 o più anni
3

ruby+

Abbina "strofina" più 1 o più anni
4

\d{3}

Trova esattamente 3 cifre
5

\d{3,}

Corrisponde a 3 o più cifre
6

\d{3,5}

Trova la corrispondenza di 3, 4 o 5 cifre

Ripetizione non soddisfacente

Questo corrisponde al minor numero di ripetizioni -

Sr.No. Esempio e descrizione
1

<.*>

Ripetizione avida: corrisponde a "<python> perl>"
2

<.*?>

Nongreedy: trova "<python>" in "<python> perl>"

Raggruppamento con parentesi

Sr.No. Esempio e descrizione
1

\D\d+

Nessun gruppo: + si ripete \ d
2

(\D\d)+

Raggruppato: + ripete la coppia \ D \ d
3

([Pp]ython(, )?)+

Trova "Python", "Python, python, python", ecc.

Backreferences

Questo corrisponde di nuovo a un gruppo precedentemente abbinato -

Sr.No. Esempio e descrizione
1

([Pp])ython&\1ails

Abbina Python e Pails o Python e Pails
2

(['"])[^\1]*\1

Stringa tra virgolette singole o doppie. \ 1 corrisponde a qualsiasi corrispondenza del primo gruppo. \ 2 corrisponde a qualunque sia il 2 ° gruppo abbinato, ecc.

Alternative

Sr.No. Esempio e descrizione
1

python|perl

Trova "python" o "perl"
2

rub(y|le))

Trova "rubino" o "rublo"
3

Python(!+|\?)

"Python" seguito da uno o più! o uno?

Ancore

Questo deve specificare la posizione della partita.

Sr.No. Esempio e descrizione
1

^Python

Trova "Python" all'inizio di una stringa o di una riga interna
2

Python$

Trova "Python" alla fine di una stringa o di una riga
3

\APython

Trova "Python" all'inizio di una stringa
4

Python\Z

Trova "Python" alla fine di una stringa
5

\bPython\b

Trova "Python" in corrispondenza del confine di una parola
6

\brub\B

\ B è un confine non di parole: trova "rub" in "rube" e "ruby" ma non da solo
7

Python(?=!)

Trova "Python", se seguito da un punto esclamativo.
8

Python(?!!)

Trova "Python", se non seguito da un punto esclamativo.

Sintassi speciale con parentesi

Sr.No. Esempio e descrizione
1

R(?#comment)

Corrisponde a "R". Tutto il resto è un commento
2

R(?i)uby

Senza distinzione tra maiuscole e minuscole durante la corrispondenza di "uby"
3

R(?i:uby)

Come sopra
4

rub(?:y|le))

Raggruppa solo senza creare \ 1 backreference