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.
Le espressioni regolari sono un costrutto di programmazione avanzato, che pochi tutorial di Python trattano in modo dettagliato. Se siete interessati ad altri aspetti avanzati della programmazione in Python, vi suggeriamo questi articoli:
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.
Se lavorate a un progetto web con Python, le espressioni regolari vi torneranno utili in molte situazioni. Un altro strumento valido è Deploy Now di IONOS, che vi permette di compilare e distribuire i vostri progetti web direttamente tramite GitHub.
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:
| Carattere | Descrizione | Esempio |
|---|---|---|
| . | Indica qualsiasi carattere, tranne le interruzioni di riga (newline) | “ci.o” -> trova tutte le stringhe che iniziano con “ci“, seguito da un carattere qualsiasi, e che terminano in “o”, ad esempio “ciao” |
| [] | Trova tutte le lettere indicate dentro le parentesi | “[a-e]” -> trova tutte le lettere minuscole tra a ed e |
| ^ | Controlla se la stringa inizia con il carattere o la sequenza di caratteri specificati | “^ciao” -> verifica se la stringa inizia con “ciao” |
| $ | Controlla se la stringa termina con il carattere o la sequenza di caratteri specificati | “$mondo” -> controlla se la stringa finisce con “mondo” |
| * | Nessuna ricorrenza o ricorrenza multipla di un carattere | “a*” -> trova la corrispondenza con un numero qualsiasi di a oppure con nessuna a |
| + | Presenza singola o multipla di un carattere | “a+” -> trova la corrispondenza con almeno una a |
| ? | Una o nessuna occorrenza di un carattere | “a?” -> trova la corrispondenza con una sola a o con nessuna a |
| {} | Verifica se un carattere è presente con la stessa frequenza indicata tra le parentesi graffe | “ci{1}o” -> trova la corrispondenza nella stringa “ciao” |
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:
| Set | Descrizione |
|---|---|
[abc]
|
Trova la corrispondenza quando uno dei caratteri indicati tra parentesi (dunque a, b o c) è presente all’interno di una stringa |
[^abc]
|
Trova tutti i caratteri non indicati tra le parentesi |
[a-z]
|
Corrisponde a tutte le lettere minuscole tra a e z |
[a-zA-Z]
|
Trova tutte le lettere tra a e z, a prescindere che siano maiuscole o minuscole |
[0-9]
|
Corrisponde con qualsiasi numero tra 0 e 9 |
[1-5][0-9]
|
Trova tutti i numeri a due cifre tra 10 e 59 |
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.
| Sequenza | Descrizione | Esempio |
|---|---|---|
| \A | Trova la corrispondenza quando la sequenza di caratteri specificata si trova all’inizio di una stringa. | “\ALunedì”
|
| \b | Trova la corrispondenza quando la sequenza di caratteri specificata si trova all’inizio o alla fine di una parola. | “\bve”
|
| \B | Trova la corrispondenza quando la sequenza di caratteri specificata non si trova all’inizio o alla fine di una parola; è il contrario di \b | “\Bve”
|
| \d | Trova tutte le cifre fra 0 e 9; equivalente a [0-9] | “123”
|
| \D | Trova tutti i caratteri che non sono cifre; equivalente a [^0-9] | “123acb&”
|
| \s | Trova la corrispondenza quando la stringa contiene uno spazio | “Python RegEx”
|
| \S | Trova la corrispondenza quando la stringa non contiene nessuno spazio; è il contrario di \s | “Python RegEx”
|
| \w | Trova tutti i caratteri alfanumerici | “1abc$%3”
|
| \W | Trova tutti i caratteri tranne quelli alfanumerici; è il contrario di \w | <“1abc$%3”
|
| \Z | Trova la corrispondenza quando la sequenza di caratteri specificata si trova alla fine di una stringa | “Python\Z”
|
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 rere.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.