4.2.1 Sintassi delle espressioni regolari

Un'espressione regolare (comunemente abbreviata in RE, dall'Inglese Regular Expression) specifica un insieme di stringhe che vi corrispondono; le funzioni in questo modulo permettono di controllare se una particolare stringa corrisponde ad una data espressione regolare (o se una data espressione regolare corrisponde ad una data stringa, che poi è la stessa cosa).

Le espressioni regolari possono venire concatenate per formare una nuova espressione regolare; se A e B sono entrambe espressioni regolari, allora anche AB è un'espressione regolare. In generale, se una stringa p corrisponde ad A e un'altra stringa q corrisponde a B, la stringa pq corrisponderà ad AB. Questo è vero meno che A o B contengano operazioni a bassa precedenza, condizioni al contorno tra A e B, o abbiamo riferimenti di gruppo numerati. Così, espressioni complessse possono facilmente venire costruite partendo da espressioni primitive più semplici, come quelle descritte qui. Per i dettagli sulla teoria e l'implementazione delle espressioni regolari, consultate il libro di Friedl (vedete il riferimento sopra) o un qualsiasi libro sulla creazione di compilatori.

Qui di seguito si troverà una breve spiegazione sul formato delle espressioni regolari. Per maggiori informazioni e una spiegazione più particolareggiata, consultate l'HOWTO sulle Espressioni Regolari, accessibile all'URL http://www.python.org/doc/howto/.

Le espressioni regolari possono contenere sia caratteri speciali che ordinari. Caratteri più ordinari singoli, come "A", "a", o "0", sono le espressioni regolari più semplici; semplicemente corrispondono a se stessi. Potete concatenare i caratteri ordinari, così last corrisponde alla stringa 'last'. (Nel resto di questa sezione, scriveremo le espressioni regolari in questo modo particolare, generalmente senza quotatura, e le stringhe da corrispondere tra 'virgolette'.)

Alcuni caratteri, come "|" o "(", sono speciali. I caratteri speciali possono indicare sia classi di carattere ordinarie, sia modificatori dell'interpretazione delle espressioni regolari indicate da questi.

I caratteri speciali sono:

"."

(Punto, in inglese "dot"). Nella modalità predefinita, questo corrisponde a qualunque carattere, ad eccezione del fine riga. Se l'opzione DOTALL viene specificata, il punto corrisponde a qualunque carattere, fine riga compreso.

"^"

(Cappelletto, in inglese "caret"). Corrisponde all'inizio di una stringa, e nella modalità MULTILINE corrisponde anche all'inizio di ogni nuova riga, ovvero dopo ogni carattere di fine riga.

"$"

Corrisponde alla fine della stringa o prima del carattere di fine riga alla fine della stringa; nella modalità MULTILINE corrisponde prima di ogni fine riga. foo corrisponde sia a 'foo' che a 'foobar', mentre l'espressione regolare foo$ corrisponde solo a 'foo'. L'espressione regolare foo.$ in 'foo1\ nfoo2\n' restituisce la corrispondenza 'foo2' normalmente, ma 'foo1' nella modalità MULTILINE.

"*"

Fa sì che l'espressione regolare risultante corrisponda a 0 o più ripetizioni della precedente espressione regolare, un numero qualunque di ripetizioni è possibile. ab* corrisponde ad 'a', 'ab' o 'a' seguita da qualunque numero di 'b'.

"+"

Fa sì che l'espressione regolare risultante corrisponda a 1 o più ripetizioni della precedente espressionre regolare. ab+ corrisponderà ad 'a' seguita da un qualunque numero, diverso da zero, di 'b'; non corrisponde alla stringa 'a'.

"?"

Fa sì che l'espressione regolare risultante corrisponda a 0 o 1 ripetizioni della precedente espressione regolare. ab? corrisponderà sia ad 'a' che ad 'ab'.

*?, +?, ??

I qualificatori "*", "+" e "?" sono ingordi; corrispondono a tutto il testo possibile. A volte questo comportamento non è quello desiderato; se l'espressione regolare <.*> viene fatta corrispondere alla stringa '<H1>title</H1>', corrisponderà all'intera stringa e non solo a '<H1>'. Aggiungere il carattere "?" dopo il qualificatore rende la ricerca delle corrispondenze non non-ingorda o minimale; verrà fatto corrispondere il minor numero possibile di caratteri. Usando .*? nella precedente espressione vi sarà corrispondenza solamente con '<H1>'.

{m}

Specifica che devono corrispondere esattamente m copie della precedente espressione regolare; un numero minore di corrispondenze farà sì che l'intera espressione regolare non corrisponda. Per esempio, a{6} corrisponderà esattamente con sei caratteri "a", ma non con cinque.

{m,n}

Fa sì che la risultante espressione regolare corrisponda da m a n ripetizioni dell'espressione regolare precedente, cercando di far corrispondere più ripetizioni possibili. Per esempio, a{3,5} corrisponderà da tre a cinque caratteri "a". Omettendo m si specifica un limite inferiore di zero e omettendo n si specifica un limite superiore infinito. Come esempio a{4,}b corrisponderà con aaaab o con un migliaio di caratteri "a" seguiti da una b, ma non ad aaab. La virgola non dovrebbe venire omessa, o il modificatore potrebbe venire confuso con la forma descritta in precedenza.

{m,n}?

Fa sì che l'espressione regolare risultante corrisponda da m a n ripetizioni della precedente espressione regolare, cercando di far corrispondere il minor numero di ripetizioni possibili. Questa è la versione non ``ingorda'' del precedente qualificatore. Per esempio, nella stringa di 6 caratteri 'aaaaaa', a{3,5} farà corrispondere cinque caratteri "a", mentre a{3,5}? farà corrispondere solo tre caratteri.

"\"

Utilizzato sia come sequenza di escape per i caratteri speciali (consentendo la corrispondenza di caratteri come "*", "?" e così via), sia per segnalare una sequenza speciale; le sequenze speciali vengono discusse di seguito.

Se non state utilizzando una stringa raw per rappresentare il modello, ricordatevi che Python usa anche i backslash come una sequenza di escape nelle costanti letterali; se la sequenza di escape non viene riconosiuta dal parser di Python, il backslash ed i caratteri seguenti vengono inclusi nella stringa risultante. Tuttavia, nel caso in cui se Python riconoscesse la sequenza risultante, il backslash dovrebbe venire ripetuto due volte. Questo è complicato e difficile da comprendere, perciò è altamente raccomandato che utilizziate sempre le stringhe raw, tranne che per le espressioni più semplici.

[]

Vengono utilizzate per indicare un insieme di caratteri. I caratteri possono venire elencati individualmente, o un intervallo di caratteri può venire indicato fornendo due caratteri separati da un trattino ("-"). I caratteri speciali non sono attivi all'interno degli insiemi. Per esempio, [akm$] corrisponderà ognuno dei caratteri "a", "k", "m" o "$"; [a-z] corrisponderà a tutte le lettere minuscole, e [a-zA-Z0-9] corrisponderà ad ogni lettera o cifra. Le classi di caratteri come \w o \S (definite di seguito) sono anche acettabili all'interno di un intervallo. Se voleste includere un carattere "]" o "-" in un insieme, fatelo precedere da un backslash o indicatelo come primo carattere dell'intervallo. Il modello []] corrisponderà alla stringa ']', per esempio.

Potete far corrispondere i caratteri non compresi in un determinato intervallo. Questo viene indicato includendo il carattere "^" come primo carattere dell'insieme; "^" altrove corrisponderà semplicemente con il carattere "^". Per esempio, [^5] corrisponderà con ogni carattere escluso "5", e [^^] corrisponderà con ogni carattere eccetto "^".

"|"

A|B, dove A e B possono essere espressioni regolari arbitrarie, crea un'espressione regolare che corrisponderà ad A o a B. Un numero arbitrario di espressioni regolari possono venire separate dal carattere "|" in questo modo. Può venire utilizzato anche all'interno dei gruppi (vedete di seguito). Come la stringa bersaglio viene analizzata, le espressioni regolari vengono provate da sinistra a destra. Quando un modello corrisponde completamente, quel ramo viene accettato. Questo significa che quando A corrisponde, B non verrà testata, anche se dovesse avere una corrispondenza maggiore. In altre parole, l'operatore "|" non è mai ``ingordo''. Per far corrispondere una costante "|", utilizzate \|, oppure inseritela in una classe di caratteri, come in [|].

(...)

Fa corrispondere qualunque espressione regolare nelle parentesi, e indica l'inizio e la fine di un gruppo; i contenuti di un gruppo possono venire recuperati dopo che una corrispondenza viene verificata, e possono essere nuovamente fatte corrispondere nella stringa con la sequenza speciale \ numero, descritta di seguito. Per far corrispondere le costanti "(" o ")", utilizzate $ o $ oppure inseritele in una classe di caratteri: [(] [)].

(?...)

Questa è una notazione di estensione (un "?" che segue un "(" non ha significato, altrimenti). Il primo carattere dopo "?" determina il significato e l'ulteriore sintassi del costrutto. Le estensioni normalmente non creano un nuovo gruppo; (?P<nome>...) è la sola eccezione a questa regola. Di seguito vengono indicate le estenzioni attualmente supportate.

(?iLmsux)

(Una o più lettere dall'insieme "i", "L", "m", "s", "u", "x".) Il gruppo corrisponde la stringa vuota; l'insieme delle lettere impostano le opzioni corrispondenti (re.I, re.L, re.M, re.S, re.U, re.X) per l'intera espressione regolare. Questo è utile se volete includere le opzioni come parte dell'espressione regolare, invece che passarle come argomento di opzione alla funzione compile().

Notate che il flag (?x) cambia il modo di analizzare l'espressione. Dovrebbe venire all'inizio della stringa modello, o dopo uno o più caratteri di spaziatura. Se ci sono dei caratteri non di spaziatura prima dell'opzione, i risultati sono indefiniti.

(?:...)

Una versione delle parentesi che non indica un gruppo. Fa corrispondere qualsiasi espressione regolare contenuta tra parentesi, ma la sotto stringa corrisposta dal gruppo non può venire recuperata dopo aver soddisfatto una corrispondenza, e non può successivamente venire referenziata nel modello.

(?P<name>...)

Simile alle parentesi regolari, ma la sotto stringa corrispondente al gruppo è accessibile attraverso il gruppo simbolico name. I nomi dei gruppi devono essere identificatori validi in Python, ed ogni nome di gruppo deve venire definito solo una volta in un'espressione regolare. Un gruppo simbolico è anche un gruppo numerato, come se il gruppo non fosse nominato. Perciò il gruppo chiamato 'id' nell'esempio sottostante può anche venire riferito come il gruppo numerato 1.

Per esempio, se il modello è (?P<id>[a-zA-Z_]\w*), il gruppo può venire riferito dal suo nome, negli argomenti ai metodi degli oggetti corrispondenti, come m.group('id') o m.end('id'), e anche attraverso il nome nel testo del modello (per esempio, (?P=id) ed il testo di sostituzione (come \g<id>).

(?P=name)

Fa corrispondere qualunque testo precedentemente corrisposto, ad un gruppo chiamato name.

(?#...)

Un commento; il contenuto delle parentesi viene semplicemente ignorato.

(?=...)

Corrisponde se ... corrisponde successivamente, ma non consuma nessun carattere della stringa. Viene chiamata asserzione di lookahead (NdT: letteralmente "guarda avanti"). Per esempio, Isaac (?=Asimov) corrisponderà con 'Isaac ' solo se seguito da 'Asimov'.

(?!...)

Corrisponde se ... non corrisponde successivamente. Questa è un'asserzione di lookahead negativa. Per esempio, Isaac (?!Asimov) corrisponderà ad 'Isaac ' solo se non seguito da 'Asimov'.

(?<=...)

Corrisponde se la posizione corrente nella stringa viene preceduta da una corrispondenza per ... che termina esattamente alla posizione corrente. Questa viene chiamata un'asserzione di lookbehind positiva. (?<=abc)def troverà un corrispondenza in "abcdef", perché il lookbehind controllerà i 3 caratteri predecenti e verificherà se esiste corrispondenza con il modello contenuto. Il modello contenuto deve solo corrispondere stringhe di una data lunghezza fissa, questo significa che abc o a|b vengono ammesse, ma a* e a{3,4} no. Notate che i modelli che iniziano con un'asserzione di lookbehind positiva non corrisponderanno mai all'inizio della stringa cercata; desidererete molto probabilmente usare la funzione search() piuttosto che la funzione match():

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

Questo esempio cerca una parola preceduta da un trattino:

>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

(?<!...)

Corrisponde se la posizione corrente nella stringa non viene preceduta da una corrispondenza per .... Questa viene chiamata asserzione di lookbehind negativa. Similmente all'asserzione di lookbehind positiva, il modello contenuto può solo essere una stringa a lunghezza fissa. I modelli che iniziano con un'asserzione di lookbehind negativa possono corrispondere all'inizio della stringa ricercata.

(?(id/name)yes-pattern|no-pattern)

Proverà a corrispondere con yes-pattern se il gruppo con il dato id o il name indicato esiste, e con no-pattern se non esiste. |no-pattern è opzionale e può venire omesso. Per esempio, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>) è un semplice sistema di corrispondenza per gli indirizzi e-mail, che corrisponderà con '<user@host.com>' e 'user@host.com', ma non con '<user@host.com'. Nuovo nella versione 2.4.

Le sequenze speciali consistono di "\" e di un carattere dalla lista seguente. Se il carattere ordinario non è nella lista, l'espressione regolare risultante corrisponderà al secondo carattere. Per esempio, \$ corrispondere al carattere "$".

\number: Fa sì che corrisponda il contenuto del gruppo con lo stesso numero. I gruppi vengono numerati a partire da 1. Per esempio, (.+) \1 corrisponde a 'the the' o a '55 55', ma non a 'the end'. (notate lo spazio dopo il primo gruppo). Questa sequenza speciale può venire utilizzata soltanto per far corrispondere uno dei primi 99 gruppi. Se la prima cifra di number è 0, o se il number è di 3 cifre ottali, non verrà interpretato come una corrispondenza su un gruppo, ma come il carattere corrispondente al numero espresso in valore ottale. Tra i caratteri "[" e "]" di una classe di caratteri, tutti gli escape numerici vengono trattati come caratteri.
\A: Corrisponde solo all'inizio della stringa.
\b: Fa sì che corrisponda la stringa vuota, ma solo all'inizio o alla fine di una parola. Una parola viene definita come una sequenza di caratteri alfanumerici e underscore, perciò la fine di una parola viene indicata da un carattere di spaziatura, o un carattere che non sia nè alfanumerico nè un underscore. Notate che \b viene definito come il contorno tra \w e \W, così il preciso insieme di caratteri alfanumerici dipende dai valori delle opzioni UNICODE e LOCALE. All'interno di un intervallo di caratteri, \b rappresenta il carattere di backspace, per compatibilità con le stringhe costanti di Python.
\B: Corrisponde alla stringa vuota, ma solo quando non si trova all'inizio o alla fine di una parola. Questo è l'opposto di \b, quindi è anche esseo soggetto alle impostazioni di LOCALE e UNICODE.
\d: Corrisponde ogni cifra decimale; è equivalente all'insieme [0-9].
\D: Corrisponde qualsiasi carattere che non sia una cifra; è equivalente all'insieme [^0-9].
\s: Fa sì che corrisponda ogni carattere di spaziatura; è equivalente all'insieme [ \t\n\r\f\v].
\S: Fa sì che corrisponda ogni carattere che non sia di spaziatura; è equivalente all'insieme [^ \t\n\r\f\v].
\w: Quando le opzioni LOCALE e UNICODE non vengono specificate, corrisponde a qualsiasi carattere alfanumerico e di trattino basso; questo è equivalente all'insieme [a-zA-Z0-9_]. Con LOCALE, farà corrispondere l'insieme [0-9_] più qualsiasi carattere definito come alfanumerico nella localizzazione corrente. Se UNICODE è impostato, questo farà corrispondere i caratteri [0-9_] più qualunque carattere classificato come alfanumerico nel database delle proprietà dei caratteri Unicode.
\W: Quando le opzioni LOCALE e UNICODE non vengono specificate, fa corrispondere qualsiasi carattere non alfanumerico; questo è equivalente all'insieme [^a-zA-Z0-9_]. Con LOCALE, farà corrispondere ogni carattere non presente nell'insieme [0-9_] e non definito come alfanumerico, nella localizzazione corrente. Se UNICODE è impostato, questo farà corrispondere qualsiasi cosa, tranne [0-9_] e i caratteri segnati come alfanumerici nel database delle proprietà dei caratteri Unicode.
\Z: Corrisponde solo alla fine della stringa.

La maggior parte degli escape standard supportati dalle stringhe costanti Python vengono anche accettati dall'analizzatore delle espressioni regolari:

\a      \b      \f      \n
\r      \t      \v      \x
\\

Gli escape ottali vengono inclusi in una forma limitata: se la prima cifra è uno 0, o ci sono tre cifre ottali, viene considerato un escape ottale. Altrimenti è il riferimento ad un gruppo.

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.