Le RegEx in Python: come funzionano le espressioni regolari nell’amato linguaggio di programmazione

Le espressioni regolari, in breve RegEx, possono essere utilizzate in Python dopo aver importato il pacchetto integrato “re” per cercare determinati modelli all’interno delle stringhe.

Cosa sono esattamente le RegEx in Python?

Per RegEx si intendono le espressioni regolari, ovvero stringhe che definiscono modelli di ricerca specifici. Possono essere utilizzate per trovare corrispondenze di modelli nelle stringhe in Python. Seguono una propria sintassi e una propria semantica.

Campi di applicazione delle RegEx in Python

Le espressioni regolari sono spesso utilizzate per cercare un determinato formato negli input degli utenti di un programma.

Un caso che sicuramente conoscerete già è ad esempio la creazione di una password che deve contenere almeno una lettera maiuscola e almeno un numero. Le RegEx di Python possono essere utilizzate per controllare che l’input sia conforme alle regole.

Spesso anche per la compilazione di moduli web si utilizzano le espressioni regolari per verificare la validità dei dati inseriti dagli utenti. Così, ad esempio, si può valutare se l’indirizzo e-mail inserito è effettivamente un indirizzo e-mail con il formato valido.

Sintassi e semantica delle RegEx in Python

All’interno delle espressioni regolari si utilizzano i cosiddetti metacaratteri. Si tratta di caratteri che nelle RegEx di Python hanno un significato particolare. Trovate i metacaratteri principali, il loro significato e un esempio nella tabella seguente:

Set

Per la maggior parte delle RegEx di Python sono particolarmente importanti i set, che vale la pena di analizzare più da vicino. I set sono modelli RegEx che iniziano e finiscono con parentesi quadre. Nella tabella sopra avete già visto un esempio di set che trova tutte le lettere minuscole tra a ed e. Di seguito trovate un riepilogo dei casi di utilizzo più frequenti dei set nelle RegEx in Python:

Come potete vedere, i set sono uno strumento potente per diverse espressioni regolari. Dovete tuttavia tenere presente che i metacaratteri presentati sopra non hanno alcun significato specifico all’interno delle parentesi quadre. Il set [] trova quindi tutti gli in una data stringa.

Sequenze

Oltre ai metacaratteri di cui abbiamo parlato sopra, nelle RegEx di Python potete utilizzare sequenze predefinite per creare modelli di ricerca precisi.

Funzioni per usare le RegEx in Python

Per utilizzare le RegEx in Python sono disponibili svariate funzioni predefinite. Tutte queste funzioni si trovano in un modulo Python chiamato “re”, che deve essere importato prima di poter lavorare con le espressioni regolari:

import re

re.findall()

La funzione più importante per usare le RegEx in Python è indubbiamente findall(). Riceve un modello di ricerca e una stringa Python e restituisce una lista Python di stringhe che contiene tutte le corrispondenze nell’ordine in cui sono state trovate. Se non viene trovata nessuna occorrenza, findall() restituisce una lista vuota.

Per illustrare la funzione osserviamo questo esempio di codice:

import re
string = "python 3.0"
regex = "\D"
risultato = re.findall(regex, string)
print(risultato)

Nel frammento di codice sopra, per prima cosa si importa il modulo re. Nella variabile chiamata “string” si inserisce poi la sequenza di caratteri “python 3.0”. Il modello di ricerca salvato nella variabile chiamata “regex”, che avete già visto nella tabella delle sequenze, trova tutti i caratteri che non sono cifre. Questo abbinamento è realizzato con la funzione findall(), che come parametro di trasferimento riceve il modello di ricerca e la stringa da cercare. La lista generata viene inserita nella variabile chiamata “risultato” e restituita sullo schermo chiamando la funzione print in Python. L’output si presenta come segue:

['p', 'y', 't', 'h', 'o', 'n', ' ', '.']

La lista contiene tutti i caratteri della stringa a eccezione delle cifre. Occorre tenere presente che anche uno spazio vuoto è considerato un carattere e quindi compare all’interno della lista.

re.sub()

La funzione sub() sovrascrive tutte le corrispondenze con un testo a vostra scelta. Come findall(), la funzione prende come primo parametro di trasferimento anche un’espressione regolare. Il testo con cui sostituire le corrispondenze deve essere passato come secondo parametro di trasferimento. Il terzo parametro di trasferimento della funzione è la stringa da cercare. Se volete sovrascrivere non tutte le corrispondenze, ma soltanto un determinato numero, potete specificare come quarto parametro di trasferimento un numero che indichi quante corrispondenze devono essere sostituite a partire dalla prima.

Anche in questo caso è utile un esempio di codice per illustrare il funzionamento:

import re
string = "python è un linguaggio fantastico"
regex = "\s"
risultato1 = re.sub(regex, "0", string)
print(risultato1)
risultato2 = re.sub(regex, "0", string, 2)
print(risultato2)

Di nuovo, per prima cosa si importa re, poi si inserisce una sequenza di caratteri nella variabile “string”. Conoscete già il modello di ricerca da utilizzare: deve trovare tutti gli spazi in una stringa.

Seguono poi due chiamate simili di sub(): la prima chiamata deve sostituire tutti gli spazi nella stringa passata con uno 0 e salvare il risultato nella variabile “risultato1”. La seconda chiamata limita il numero di spazi con il quarto parametro di trasferimento opzionale. Deve sostituire i primi due spazi con uno 0 nella stringa passata e poi salvare il risultato nella variabile “risultato2”.

L’output del codice sopra si presenta quindi come segue:

'python0è0un0linguaggio0fantastico'
'python0è0un linguaggio fantastico'

re.split()

Come già si intuisce dal nome, split() del modulo re ricorda il funzionamento della funzione split() integrata in Python. Anch’essa divide una stringa in una lista. La stringa viene interrotta dopo ogni corrispondenza con un’espressione regolare. Pertanto, non sorprende che la funzione si aspetti come primo parametro un modello di ricerca e come secondo parametro la stringa da dividere. Se volete dividere solo in modo limitato, potete passare un numero come terzo parametro opzionale, che determina il numero massimo di divisioni. Ricorriamo di nuovo a un esempio pratico:

import re
string = "python è un linguaggio fantastico"
regex = "\s"
risultato1 = re.split(regex, string)
print(risultato1)
risultato2 = re.split(regex, string, 1)
print(risultato2)

Conoscete gran parte del codice già dall’esempio precedente. Cambia soltanto la chiamata della funzione split(). Per prima cosa si chiama la funzione split() nella stringa, che deve essere divisa ogni volta che è presente uno spazio. Alla lista risultante viene assegnata la variabile “risultato1”. La seconda chiamata split() limita il numero di divisioni indicate dal terzo parametro opzionale a 1 e assegna il risultato alla variabile chiamata “risultato2”. All’esecuzione del programma viene restituito il risultato seguente:

['python', 'è', 'un', 'linguaggio', 'fantastico']
['python', 'è un linguaggio fantastico']

re.search()

Come suggerisce il nome, la funzione search() cerca una corrispondenza in una stringa. A questo scopo riceve prima l’espressione regolare e poi, come secondo parametro, la stringa in cui eseguire la ricerca. Restituisce un oggetto Match Python che si riferisce sempre alla corrispondenza precedentemente trovata. Se non viene trovata nessuna corrispondenza, la funzione restituisce il valore “None”. Anche questa volta un esempio aiuta a comprendere come lavora questa funzione:

import re
string = "python è un linguaggio fantastico"
regex = "\s"
match = re.search(regex, string)
if match:
	print("RegEx trovata.")
else:
	print("RegEx non trovata.")

La funzione search() viene chiamata con un’espressione regolare che cerca gli spazi e una stringa. L’oggetto Match restituito dalla chiamata della funzione viene salvato nella variabile “match”. La successiva istruzione if-else in Python aiuta a chiarire: se è stata trovata una corrispondenza, l’oggetto Match non è vuoto e viene selezionato il percorso if. Non sorprende che il programma fornisca l’output seguente:

'RegEx trovata.'

L’oggetto Match

L’oggetto Match è restituito da una chiamata search() e contiene informazioni sulle occorrenze trovate del modello di ricerca. A queste informazioni potete accedere con diverse funzioni:

• object.start() fornisce l’indice del primo carattere della sottostringa Python che corrisponde al vostro modello di ricerca.
• object.end(), analogamente a start(), restituisce l’indice dell’ultimo carattere.
• object.span() unisce start() ed end(): la funzione restituisce una tupla Python che contiene il primo e l’ultimo indice della sottostringa.
• object.string restituisce la stringa analizzata.
• object.re restituisce la RegEx Python che avete passato a search().

Per chiarire tutte queste funzioni, aggiungiamo chiamate di funzioni idonee all’ultimo esempio di codice:

import re
string = "python è un linguaggio fantastico"
regex = "\s"
match = re.search(regex, string)
if match:
	print("RegEx trovata.")
else:
	print("RegEx non trovata.")
print(match.start())
print(match.end())
print(match.span())
print(match.string)
print(match.re())

L’output del programma si presenta come segue:

'RegEx trovata.'
6
7
(6, 7)
'python è un linguaggio fantastico'
re.compile('\\s')

Innanzitutto viene restituita la stringa “RegEx trovata.”, in quanto l’oggetto Match non è vuoto e quindi la condizione if è soddisfatta. In seguito, viene visualizzato l’indice della prima corrispondenza. Siccome il primo spazio ha l’indice “6”, il valore non sorprende. Lo stesso vale per il valore “7” che viene restituito a seguito della chiamata della funzione end(). La tupla “(6, 7)” unisce la chiamata di start() ed end(), indicando i due indici insieme. Anche l’output della stringa passata all’oggetto Match non stupisce.

Quindi cosa ha di speciale l’output “re.compile(’\s’)”? Si tratta di un oggetto RegEx in Python generato quando la stringa che avete passato come espressione regolare viene elaborata come tale. Come vedete, tramite il vostro oggetto Match potete visualizzare l’oggetto RegEx.