Perl - espressioni regolari

Un'espressione regolare è una stringa di caratteri che definisce il modello o i modelli visualizzati. La sintassi delle espressioni regolari in Perl è molto simile a quella che troverai in altri programmi di supporto di espressioni regolari, comesed, grep, e awk.

Il metodo di base per applicare un'espressione regolare consiste nell'usare gli operatori di associazione del modello = ~ e !~. Il primo operatore è un operatore di test e assegnazione.

Ci sono tre operatori di espressioni regolari in Perl.

• Match Regular Expression - m //
• Espressione regolare sostitutiva - s ///
• Espressione regolare traslitterata - tr ///

Le barre in avanti in ogni caso fungono da delimitatori per l'espressione regolare (regex) che stai specificando. Se ti senti a tuo agio con qualsiasi altro delimitatore, puoi usarlo al posto della barra in avanti.

L'operatore di corrispondenza

L'operatore di corrispondenza, m //, viene utilizzato per abbinare una stringa o un'istruzione a un'espressione regolare. Ad esempio, per abbinare la sequenza di caratteri "pippo" alla barra $ scalare, potresti usare un'istruzione come questa:

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

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

First time is matching
Second time is matching

In realtà, m // funziona allo stesso modo della serie di operatori q //. Puoi utilizzare qualsiasi combinazione di caratteri che corrispondono naturalmente per agire come delimitatori per l'espressione. Ad esempio, m {}, m () e m> <sono tutti validi. Quindi l'esempio sopra può essere riscritto come segue:

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Puoi omettere m da m // se i delimitatori sono barre, ma per tutti gli altri delimitatori devi usare il prefisso m.

Si noti che l'intera espressione di corrispondenza, ovvero l'espressione a sinistra di = ~ o! ~ E l'operatore di corrispondenza, restituisce true (in un contesto scalare) se l'espressione corrisponde. Pertanto la dichiarazione -

$true = ($foo =~ m/foo/);

imposterà $ true a 1 se $ foo corrisponde alla regex, o 0 se la corrispondenza fallisce. In un contesto di elenco, la corrispondenza restituisce il contenuto di qualsiasi espressione raggruppata. Ad esempio, quando si estraggono ore, minuti e secondi da una stringa temporale, è possibile utilizzare:

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Modificatori dell'operatore di corrispondenza

L'operatore di corrispondenza supporta il proprio set di modificatori. Il modificatore / g consente la corrispondenza globale. Il modificatore / i renderà la corrispondenza senza distinzione tra maiuscole e minuscole. Ecco l'elenco completo dei modificatori

Sr.No.	Modificatore e descrizione
1	i Rende la corrispondenza senza distinzione tra maiuscole e minuscole.
2	m Specifica che se la stringa ha caratteri di ritorno a capo o di ritorno a capo, gli operatori ^ e $ ora corrisponderanno a un limite di nuova riga, anziché a un limite di stringa.
3	o Valuta l'espressione solo una volta.
4	s Consente l'uso di. per abbinare un carattere di nuova riga.
5	x Consente di utilizzare lo spazio bianco nell'espressione per maggiore chiarezza.
6	g Globalmente trova tutte le corrispondenze.
7	cg Consente la ricerca di continuare anche dopo che una corrispondenza globale fallisce.

Corrispondenza solo una volta

Esiste anche una versione più semplice dell'operatore di corrispondenza: il? PATTERN? operatore. Questo è fondamentalmente identico all'operatore m // tranne per il fatto che corrisponde solo una volta all'interno della stringa che stai cercando tra ogni chiamata da reimpostare.

Ad esempio, puoi usarlo per ottenere il primo e l'ultimo elemento all'interno di un elenco -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/;
   $last = $1 if /(foo.*)/;
}
print "First: $first, Last: $last\n";

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

First: foo, Last: footbrdige

Variabili delle espressioni regolari

Le variabili delle espressioni regolari includono $, che contiene qualunque sia l'ultima corrispondenza di raggruppamento abbinata; $&, che contiene l'intera stringa corrispondente; $`, che contiene tutto prima della stringa corrispondente; e$', che contiene tutto ciò che segue la stringa corrispondente. Il codice seguente mostra il risultato:

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/;
print "Before: $`\n";
print "Matched: $&\n";
print "After: $'\n";

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

Before: The
Matched: foo
After: d is in the salad bar

L'operatore di sostituzione

L'operatore di sostituzione, s ///, è in realtà solo un'estensione dell'operatore di corrispondenza che consente di sostituire il testo abbinato con del nuovo testo. La forma base dell'operatore è:

s/PATTERN/REPLACEMENT/;

Il PATTERN è l'espressione regolare per il testo che stiamo cercando. REPLACEMENT è una specifica per il testo o l'espressione regolare che vogliamo utilizzare per sostituire il testo trovato. Ad esempio, possiamo sostituire tutte le occorrenze didog con cat utilizzando la seguente espressione regolare:

#/user/bin/perl

$string = "The cat sat on the mat";
$string =~ s/cat/dog/;

print "$string\n";

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

The dog sat on the mat

Modificatori dell'operatore di sostituzione

Ecco l'elenco di tutti i modificatori usati con l'operatore di sostituzione.

Sr.No.	Modificatore e descrizione
1	i Rende la corrispondenza senza distinzione tra maiuscole e minuscole.
2	m Specifica che se la stringa ha caratteri di ritorno a capo o di ritorno a capo, gli operatori ^ e $ ora corrisponderanno a un limite di nuova riga, anziché a un limite di stringa.
3	o Valuta l'espressione solo una volta.
4	s Consente l'uso di. per abbinare un carattere di nuova riga.
5	x Consente di utilizzare lo spazio bianco nell'espressione per maggiore chiarezza.
6	g Sostituisce tutte le occorrenze dell'espressione trovata con il testo sostitutivo.
7	e Valuta la sostituzione come se fosse un'istruzione Perl e utilizza il valore restituito come testo di sostituzione.

L'operatore di traduzione

La traduzione è simile, ma non identica, ai principi di sostituzione, ma a differenza della sostituzione, la traduzione (o traslitterazione) non utilizza espressioni regolari per la ricerca sui valori di sostituzione. Gli operatori di traduzione sono:

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

La traduzione sostituisce tutte le occorrenze dei caratteri in SEARCHLIST con i caratteri corrispondenti in REPLACEMENTLIST. Ad esempio, utilizzando "Il gatto seduto sul tappeto". stringa che abbiamo usato in questo capitolo -

#/user/bin/perl

$string = 'The cat sat on the mat';
$string =~ tr/a/o/;

print "$string\n";

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

The cot sot on the mot.

È possibile utilizzare anche intervalli Perl standard, che consentono di specificare intervalli di caratteri tramite lettera o valore numerico. Per modificare il caso della stringa, potresti utilizzare la seguente sintassi al posto diuc funzione.

$string =~ tr/a-z/A-Z/;

Modificatori dell'operatore di traduzione

Di seguito è riportato l'elenco degli operatori relativi alla traduzione.

Sr.No.	Modificatore e descrizione
1	c Complementi SEARCHLIST.
2	d Elimina i caratteri trovati ma non sostituiti.
3	s Le zucche duplicano i caratteri sostituiti.

Il modificatore / d elimina i caratteri che corrispondono a SEARCHLIST che non hanno una voce corrispondente in REPLACEMENTLIST. Ad esempio:

#!/usr/bin/perl 

$string = 'the cat sat on the mat.';
$string =~ tr/a-z/b/d;

print "$string\n";

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

b b   b.

L'ultimo modificatore, / s, rimuove le sequenze duplicate di caratteri che sono stati sostituiti, quindi -

#!/usr/bin/perl

$string = 'food';
$string = 'food';
$string =~ tr/a-z/a-z/s;

print "$string\n";

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

fod

Espressioni regolari più complesse

Non devi solo abbinare stringhe fisse. In effetti, puoi abbinare praticamente qualsiasi cosa tu possa sognare usando espressioni regolari più complesse. Ecco un breve cheat sheet:

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	* Corrisponde a 0 o più occorrenze dell'espressione precedente.
7	+ Corrisponde a 1 o più occorrenze dell'espressione precedente.
8	? Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
9	{ n} Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
10	{ n,} Corrisponde a n o più occorrenze dell'espressione precedente.
11	{ n, m} Corrisponde ad almeno n e al massimo m occorrenze dell'espressione precedente.
12	a| b Corrisponde a a o b.
13	\w Corrisponde ai caratteri delle parole.
14	\W Corrisponde a caratteri non di parole.
15	\s Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
16	\S Corrisponde a spazi non bianchi.
17	\d Corrisponde alle cifre. Equivalente a [0-9].
18	\D Corrisponde a non cifre.
19	\A Corrisponde all'inizio della stringa.
20	\Z Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
21	\z Corrisponde alla fine della stringa.
22	\G Punto delle partite in cui è finita l'ultima partita.
23	\b Corrisponde ai confini delle parole quando sono al di fuori delle parentesi. Corrisponde a backspace (0x08) quando è racchiuso tra parentesi.
24	\B Corrisponde ai confini non di parole.
25	\n, \t, etc. Trova nuove righe, ritorni a capo, tabulazioni, ecc.
26	\1...\9 Corrisponde all'ennesima sottoespressione raggruppata.
27	\10 Corrisponde all'ennesima sottoespressione raggruppata se corrisponde già. Altrimenti si riferisce alla rappresentazione ottale di un codice carattere.
28	[aeiou] Corrisponde a un singolo carattere nel set specificato
29	[^aeiou] Corrisponde a un singolo carattere al di fuori del set specificato

Il metacarattere ^ corrisponde all'inizio della stringa e il metasimbolo $ corrisponde alla fine della stringa. Ecco alcuni brevi esempi.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Diamo un'occhiata a un altro esempio.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm;
print "First word: $start\n","Line starts: @lines\n";

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

First word: Cats
Line starts: Cats When

Confini corrispondenti

Il \bcorrisponde a qualsiasi confine di parola, come definito dalla differenza tra la classe \ w e la classe \ W. Poiché \ w include i caratteri per una parola e \ W il contrario, questo normalmente significa la fine di una parola. Il\Bl'asserzione corrisponde a qualsiasi posizione che non sia un confine di parola. Ad esempio:

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Selezione di alternative

Il | carattere è proprio come lo standard o l'OR bit per bit all'interno di Perl. Specifica corrispondenze alternative all'interno di un'espressione regolare o di un gruppo. Ad esempio, per abbinare "gatto" o "cane" in un'espressione, potresti usare questo:

if ($string =~ /cat|dog/)

È possibile raggruppare insieme singoli elementi di un'espressione per supportare corrispondenze complesse. La ricerca dei nomi di due persone potrebbe essere ottenuta con due test separati, come questo:

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/))

This could be written as follows

if ($string =~ /(Martin|Sharon) Brown/)

Corrispondenza di raggruppamento

Da un punto di vista delle espressioni regolari, non c'è differenza tra tranne, forse, che il primo è leggermente più chiaro.

$string =~ /(\S+)\s+(\S+)/;

and 

$string =~ /\S+\s+\S+/;

Tuttavia, il vantaggio del raggruppamento è che ci consente di estrarre una sequenza da un'espressione regolare. I raggruppamenti vengono restituiti come un elenco nell'ordine in cui sono visualizzati nell'originale. Ad esempio, nel frammento seguente abbiamo estratto le ore, i minuti e i secondi da una stringa.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Oltre a questo metodo diretto, i gruppi corrispondenti sono disponibili anche all'interno delle speciali variabili $ x, dove x è il numero del gruppo all'interno dell'espressione regolare. Potremmo quindi riscrivere l'esempio precedente come segue:

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/;
my ($hours, $minutes, $seconds) = ($1, $2, $3);

print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

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

Hours : 12, Minutes: 05, Second: 30

Quando i gruppi vengono utilizzati nelle espressioni di sostituzione, la sintassi $ x può essere utilizzata nel testo di sostituzione. Quindi, potremmo riformattare una stringa di data usando questo -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

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

1999/03/26

L'asserzione \ G

L'asserzione \ G ti consente di continuare la ricerca dal punto in cui si è verificata l'ultima corrispondenza. Ad esempio, nel codice seguente, abbiamo usato \ G in modo da poter cercare nella posizione corretta e quindi estrarre alcune informazioni, senza dover creare una singola espressione regolare più complessa -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g;
($time) = ($string =~ /\G(\d+:\d+:\d+)/);
$string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

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

Time: 12:31:02, Date: 4/12/00

L'asserzione \ G è in realtà solo l'equivalente metasimbolo della funzione pos, quindi tra le chiamate di espressioni regolari puoi continuare a usare pos e persino modificare il valore di pos (e quindi \ G) usando pos come subroutine lvalue.

Esempi di espressioni regolari

Personaggi letterali

Sr.No.	Esempio e descrizione
1	Perl Trova "Perl".

Classi di caratteri

Sr.No.	Esempio e descrizione
1	[Pp]ython Corrisponde a "Python" o "python"
2	rub[ye] Corrisponde a "ruby" o "rube"
3	[aeiou] Corrisponde a una vocale qualsiasi minuscola
4	[0-9] Corrisponde a qualsiasi cifra; uguale a [0123456789]
5	[a-z] Corrisponde a qualsiasi lettera ASCII minuscola
6	[A-Z] Corrisponde a qualsiasi lettera ASCII maiuscola
7	[a-zA-Z0-9] Corrisponde a uno dei precedenti
8	[^aeiou] Corrisponde a qualsiasi cosa diversa da una vocale minuscola
9	[^0-9] Corrisponde a qualsiasi cosa diversa da una cifra

Classi di caratteri speciali

Sr.No.	Esempio e descrizione
1	. Corrisponde a qualsiasi carattere tranne la nuova riga
2	\d Corrisponde a una cifra: [0-9]
3	\D Corrisponde a una non cifra: [^ 0-9]
4	\s Corrisponde a uno spazio vuoto: [\ t \ r \ n \ f]
5	\S Corrisponde a spazi non bianchi: [^ \ t \ r \ n \ f]
6	\w Corrisponde a un carattere di una sola parola: [A-Za-z0-9_]
7	\W Corrisponde a un carattere diverso da una parola: [^ A-Za-z0-9_]

Casi di ripetizione

Sr.No.	Esempio e descrizione
1	ruby? Corrisponde a "rub" o "ruby": la y è facoltativa
2	ruby* Corrisponde a "strofinare" più 0 o più anni
3	ruby+ Corrisponde a "strofinare" più 1 o più anni
4	\d{3} Corrisponde esattamente a 3 cifre
5	\d{3,} Corrisponde a 3 o più cifre
6.	\d{3,5} Corrisponde a 3, 4 o 5 cifre

Ripetizione di Nongreedy

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 Corrisponde a 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 Corrisponde a "python" o "perl"
2	rub(y|le)) Corrisponde a "rubino" o "rublo"
3	Python(!+|\?) "Python" seguito da uno o più! o uno?

Ancore

Questa necessità di specificare le posizioni delle partite.

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 Corrisponde a "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(?=!) Corrisponde a "Python", se seguito da un punto esclamativo
8	Python(?!!) Corrisponde a "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 Non distingue 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