Cosa sono le Regex
Le espressioni regolari (o RE) sono essenzialmente un piccolo ed altamente specializzato linguaggio di programmazione incorporato in Python e reso disponibile attraverso il modulo re. Utilizzando questo piccolo linguaggio, si specificano le regole per l’insieme di possibili stringhe di cui si vogliono trovare corrispondenze; tale insieme potrebbe contenere frasi in inglese o indirizzi di posta elettronica o qualunque altra cosa vogliate.
Potete quindi porre domande tipo:
“Questa stringa ha corrispondenza in questo modello?” o
“Esiste una corrispondenza con questo modello da qualche parte nella stringa?”.
Potete utilizzare le RE anche per modificare una stringa o per spezzarla in diversi modi.
Il linguaggio delle espressioni regolari è relativamente piccolo e ristretto, quindi non tutti i compiti di elaborazione
di stringhe possono essere realizzati per mezzo delle espressioni regolari. Vi sono anche dei compiti che pur potendo essere svolti dalle espressioni regolari danno luogo a delle espressioni regolari estremamente complicate.
In questi casi, fareste meglio a scrivere del codice Python per l’elaborazione; nonostante il codice Python sia più lento di una complessa espressione regolare, probabilmente sarà più comprensibile.
Semplici modelli
Cominceremo imparando le espressioni regolari più semplici. Siccome le espressioni regolari sono utilizzate per operare sulle stringhe, inizieremo con il caso più comune: individuare caratteri.
Individuare la corrispondenza con i caratteri
La maggior parte delle lettere e dei caratteri semplicemente corrispondono a sé stessi. Per esempio, l’espressione
regolare [test] corrisponderà esattamente alla stringa ‘test’. (Potete abilitare una modalità non sensibile alle differenze tra maiuscolo e minuscolo che farebbe corrispondere questa RE anche a ‘Test’ o ‘TEST’; ( vedremo maggiori dettagli in seguito).
Vi sono eccezioni a questa regola; alcuni caratteri sono speciali e non corrispondono a sé stessi. Segnalano invece che alcune cose fuori dall’ordinario dovrebbero trovare corrispondenza o influenzare altre porzioni della RE ripetendole.
I metacaratteri
Questa è una lista completa dei metacaratteri:
. ^ $ * + ? { [ ] \ | ( )
- [ ]
[ ] Sono utilizzati per specificare classi di caratteri che sono un insieme di caratteri di cui si desidera ottenere una corrispondenza. I caratteri possono essere elencati individualmente o tramite un intervallo di caratteri che può essere indicato tramite due caratteri e separati con un ‘-’.
ESEMPIO
[abc] troverà corrispondenza con ognuno dei caratteri ‘a’, ‘b’ o ‘c’; il medesimo comportamento per [a-c], che utilizza un intervallo per esprimere il medesimo insieme di caratteri. Se volete trovare le corrispondenze solamente delle lettere minuscole la vostra RE potrebbe essere [a-z].
Abbiamo visto in
“Python: Guida alle espressioni regolari: le funzioni re.search, re.findall e re.finditer”
i metodi principali per ricercare i pattern ( modelli ) che abbiamo definito.
Metodi ⇒ Attributi Scopo
match() ⇒ Determina se la RE corrisponde all’inizio della stringa.
search() ⇒ ricerca all’interno di una stringa, trovando tutte le posizioni corrispondenti alla RE.
findall() ⇒ Trova tutte le sottostringhe corrispondenti alla RE, e le restituisce in una lista.
finditer() ⇒ Trova tutte le sottostringhe corrispondenti alla RE, e le restituisce in un iteratore.
match() e search() restituiscono None se nessuna corrispondenza viene trovata. Se hanno successo, viene restituita un’istanza MatchObject, contenente informazioni riguardo alla corrispondenza: dove inizia e dove finisce, la sottostringa a cui corrisponde e altro.
Facciamo una prova:
import repattern = '[abc]'text = 'abbiamo caldo're.search(pattern, text)if re.search(pattern, text): print ( 'trovata corrispondenza!')else: print ( 'nessuna corrispondenza')I metacaratteri non sono attivi nelle classi. Per esempio, [akm$] troverà corrispondenza con ognuno dei caratteri ‘a’, ‘k’, ‘m’ o ‘$’; ‘$’ è solitamente un metacarattere ma, in una classe di caratteri, viene privato della sua natura speciale.
- ‘ ^ ’
Potete far corrispondere i caratteri non presenti in un intervallo creando il complemento dell’insieme. Questo si indica includendo un ‘^’ come primo carattere della classe; ‘^’ in ogni altro luogo corrisponderà semplicemente al carattere ‘^’.
Per esempio [^5] darà corrispondenza ad ogni carattere eccetto il ‘5’.
ESEMPIO
L’accento ˆ , in questo caso, viene utilizzato nelle espressioni regolari per trovare l’inizio di una riga.
Troviamo in questo mini-dizionario italiano tutte le parole che iniziano per f e che hanno 2 t alla quarta e quinta posizione:
# cerchiamo le parole che inziano per 'f', seguite da 2 caratteri qualsiasi # e successivamente da 2 't:'import rehand = open('ita.txt')for line in hand: line = line.rstrip() if re.search('^f..tt', line): print(line)fiottare
fiotti
fiottio
fiotto
flatting
flette
………..
fruttuosi
fruttuosita
fruttuoso
fuetti
fuetto
Questo è un esempio molto elementare che avremmo potuto riprodurre utilizzando con il metodo startswith() incluso nella libreria delle stringhe. Ma serve per introdurre il concetto secondo cui le espressioni regolari possono contenere caratteri speciali che ci danno più controllo su ciò che confronterà l’espressione regolare.
Per approfondire le classi di negazione, clicca qui
- ‘ \ ’
Forse il metacarattere più importante è il backslash ‘\’. Come nelle stringhe costanti di Python il backslash può essere seguito da diversi caratteri per segnalare varie sequenze speciali. Viene utilizzato anche per effettuare la protezione di tutti i metacaratteri in modo da poterne trovare corrispondenza nei modelli;
per esempio, se dovete trovare la corrispondenza con una ‘[’ o una ‘\’ potete farle precedere da un backslash per
rimuovere il loro significato speciale: [ \ [ ] o [ \\].
Alcune delle sequenze speciali che iniziano con ‘\’ rappresentano degli insiemi predefiniti di caratteri che sono spesso utili, come l’insieme delle cifre, l’insieme delle lettere o l’insieme di tutto ciò che non è spazio vuoto. Sono disponibili le seguenti sequenze predefinite:
\d Corrisponde ad ogni cifra decimale; equivale alla classe[0-9].
\D Corrisponde ad ogni carattere che non sia una cifra; è equivalente alla classe [^0-9].
\s Corrisponde ad ogni carattere di spaziatura; è equivalente alla classe [ \t\n\r\f\v].
\S Corrisponde ad ogni carattere che non sia uno spazio vuoto; è equivalente alla classe [^ \t\n\r\f\v]
\w Corrisponde ad ogni carattere alfanumerico; è equivalente alla classe [a-zA-Z0-9_ ].
\W Corrisponde ad ogni carattere che non sia alfanumerico; è equivalente alla classe [^a-zA-Z0-9_ ].
Tali sequenze possono essere incluse in una classe di caratteri.
Per esempio [\s,.] è una classe di caratteri che corrisponde ad ogni carattere di spazio o ad una ‘,’ o ad un ‘.’.
- ‘ .’
L’ultimo metacarattere in questa sezione è il [.]. Corrisponde a qualunque carattere salvo il carattere di a fine riga ed esiste una modalità (re.DOTALL) in cui corrisponde anche al carattere di fine riga. ‘.’ viene spesso usato quando volete trovare corrispondenza con “ogni carattere”.
Cose che si ripetono
Il fatto di essere capaci di individuare caratteri variabili è la prima cosa che le espressioni regolari possono fare e che non era possibile con i metodi disponibili per le stringhe. Però, se questa fosse l’unica nuova risorsa offerta dalle RE, non sarebbe un gran guadagno. Un’altra caratteristica importante è quella di poter specificare parti della RE che devono essere ripetute un certo numero di volte.
- ‘ * ’
Il primo metacarattere che vedremo per esprimere ripetizioni è [*]. L’asterisco non cerca il carattere ‘*’; serve invece a specificare che il carattere che lo precede può presentarsi zero o più volte e non esclusivamente una sola volta.
Per esempio
[ca*tc] troverà corrispondenza ‘ct’ (0 caratteri ‘a’), ‘cat’ (1 ‘a’), ‘caaat’ (3 caratteri ‘a’) e così via. Il motore delle RE ha alcune limitazioni derivanti dalle dimensioni dei tipi int in C, questo vi impedirà di trovare corrispondenze con stringhe con più di 2 miliardi di ‘a’; ma probabilmente non avete abbastanza memoria per costruire una stringa tanto grande, quindi non dovreste mai raggiungere questo limite.
Ripetizioni come [*] sono golose; quando si cercano ripetizioni in una RE il motore cerca quella più lunga possibile.
Se poi alcune parti del modello non corrispondono, il motore torna indietro e riprova con meno ripetizioni.
Un esempio analizzato passo passo renderà le cose più chiare. Consideriamo l’espressione a[bcd]*b. Questa
espressione cerca una stringa che inizia con la lettera ‘a’, prosegue con zero o più lettere della classe [bcd] e termina con ‘b’. Immaginiamo adesso di provare questa RE con la stringa ‘abcbd’.
| Passo | Modello | Spiegazione |
| 1 | a | La [a] nella RE corrisponde |
| 2 | abcbd | Il motore cerca [bcd]* e va avanti il più possibile, cioè fino alla fine della stringa. |
| 3 | Fallimento | Il motore cerca la [b], ma la posizione corrente è alla fine della stringa e quindi fallisce. |
| 4 | abcb | Torna indietro, adesso [bcd]* corrisponde ad un carattere in meno |
| 5 | Fallimento | Cerca di nuovo [b], ma nella posizione corrente trova il carattere ‘d’ |
| 6 | abc | Torna indietro, in questo momento [bcd]* corrisponde solamente con ‘bc’. |
| 6 | abcb | Cerca di nuovo ‘b’. Ma stavolta il carattere nella posizione corrente è ‘b’, la ricerca ha successo. |
Il lavoro della RE è terminato e corrisponde con ‘abcb’. Questo mostra come opera l’algoritmo di ricerca, che prima va avanti il più possibile e poi, se non trova la giusta corrispondenza, torna progressivamente indietro, riprovando più e più volte. Sarebbe tornato indietro fino a cercare zero corrispondenze con [bcd]* ed al passo successivo avrebbe fallito, concludendo che la stringa non corrisponde per niente alla RE.
import repattern = 'a[bcd]*b'text = 'abcbd're.search(pattern, text)if re.search(pattern, text): print ( 'trovata corrispondenza!')else: print ( 'nessuna corrispondenza')re.findall(pattern, text)[‘abcb’]
- ‘ + ’
Un altro metacarattere per le ripetizioni è ‘+’, ed evidenzia una o più occorrenze. È necessario fare attenzione alla differenza tra ‘*’ e ‘+’:
‘*’ cerca zero o più occorrenze, quindi tutto quello che può essere ripetuto può anche essere del tutto assente, mentre con
‘+’ è necessaria almeno una occorrenza. Per usare un esempio simile al precedente, [ca+t] troverà ‘cat’ (1 ‘a’), ‘caaat’ (3 ‘a’), ma non troverà ‘ct’.
import repattern = 'ca+t'text = 'catta'if re.search(pattern, text): print ( 'trovata corrispondenza!')else: print ( 'nessuna corrispondenza')print(re.findall(pattern, text))# proviamo ora in 'ctta'pattern = 'ca+t'text = 'ctta'if re.search(pattern, text): print ( 'trovata corrispondenza!')else: print ( 'nessuna corrispondenza')re.findall(pattern, text)[‘cat’]
nessuna corrispondenza
[]
import rehand = open('ita.txt')for line in hand: line = line.rstrip() if re.search('^ab.+s.+m', line): print(line)abbandonassimo
abbassamenti
abbassamento
abbassammo
abbassassimo
abbassavamo
abbasseremmo
abbasseremo
abbassiamo
abbattessimo
abbellissimo
abbigliassimo
abbinassimo
abbindolassimo
abbiosciamenti
abbiosciamento
abbiosciamo
abbisognassimo
abbisognavamo
………………………………………
abolissimo
abortissimo
abrogassimo
abusammo
abusassimo
abusavamo
abuseremmo
abuseremo
abusiamo
abusivamente
abusivismi
abusivismo
Puoi pensare al carattere wildcard “.+” come all’estensione del controllo di tutti i caratteri inclusi tra ‘b’ e la ‘s’ e tra la ‘s’ e la ‘m’.

Prezzo: 29,99€ e Resi GRATUITI
Risparmi: 3,00€ (9%)
[elementor-template id=”12586″]
[no_toc]
(280)