re – Operazioni con le espressioni regolari¶

Sintassi delle espressioni regolari¶

Un’espressione regolare (o RE) specifica un insieme di stringhe che le 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 particolare stringa, che si riduce alla stessa cosa).

Le espressioni regolari possono essere concatenate per formare nuove espressioni regolari; se A e B sono entrambe espressioni regolari, allora anche AB è un’espressione regolare. Questo vale a meno che A o B contengano operazioni a bassa precedenza; condizioni di confine tra A e B; o abbiano riferimenti di gruppo numerati. Così, espressioni complesse possono essere facilmente costruite da espressioni primitive più semplici come quelle descritte qui. Per i dettagli della teoria e dell’implementazione delle espressioni regolari, consultate il libro di Friedl, o quasi tutti i libri di testo sulla costruzione di compilatori.

Segue una breve spiegazione del formato delle espressioni regolari. Per ulteriori informazioni e una presentazione più gentile, consultate il Regular Expression HOWTO.

Le espressioni regolari possono contenere sia caratteri speciali che ordinari. I caratteri più ordinari, come 'A', 'a', o '0', sono le espressioni regolari più semplici; corrispondono semplicemente a se stesse. Potete concatenare caratteri ordinari, così last corrisponde alla stringa 'last'. (Nel resto di questa sezione, scriveremo RE in this special style, di solito senza virgolette, e le stringhe da abbinare 'in single quotes'.)

Alcuni caratteri, come '|' o '(', sono speciali. I caratteri speciali o rappresentano classi di caratteri ordinari, o influenzano l’interpretazione delle espressioni regolari che li circondano.

I qualificatori di ripetizione (*, +, ?, {m,n}, etc) non possono essere annidati direttamente. Questo evita l’ambiguità con il suffisso del modificatore non-greedy?, e con altri modificatori in altre implementazioni. Per applicare una seconda ripetizione ad una ripetizione interna, si possono usare le parentesi. Per esempio, l’espressione (?:a{6})* corrisponde a qualsiasi multiplo di sei caratteri 'a'.

I caratteri speciali sono:

.

(Dot.) Nel modo predefinito, questo corrisponde a qualsiasi carattere eccetto un newline. Se è stato specificato il flag DOTALL, questo corrisponde a qualsiasi carattere incluso un newline.

^

(Caret.) Corrisponde all’inizio della stringa, e in modalità MULTILINE corrisponde anche immediatamente dopo ogni newline.

$

Corre alla fine della stringa o appena prima del newline alla fine della stringa, e in modalità MULTILINE corrisponde anche prima di un newline. foocerca sia ‘foo’ che ‘foobar’, mentre l’espressione regolare foo$cerca solo ‘foo’. Più interessante è il fatto che la ricerca di foo.$ in 'foo1\nfoo2\n' corrisponde a ‘pippo2’ normalmente, ma a ‘pippo1’ in modalità MULTILINE; la ricerca di un singolo $ in 'foo\n' troverà due corrispondenze (vuote): una appena prima della nuova linea, e una alla fine della stringa.

*

Fa sì che la RE risultante corrisponda a 0 o più ripetizioni della RE precedente, quante più ripetizioni sono possibili. ab* corrisponderà ad ‘a’, ‘ab’, o ‘a’ seguito da qualsiasi numero di ‘b’.

+

Fa sì che l’RE risultante corrisponda a 1 o più ripetizioni dell’RE precedente.ab+ corrisponderà ad ‘a’ seguito da qualsiasi numero non-zero di ‘b’; non corrisponderà solo ad ‘a’.

?

Fa sì che l’RE risultante corrisponda a 0 o 1 ripetizione dell’RE precedente.ab? corrisponderà o ad ‘a’ o ad ‘ab’.

*?,+?,??

I qualificatori '*', '+', e '?' sono tutti avidi; corrispondono a più testo possibile. A volte questo comportamento non è desiderato; se il RE<.*> è abbinato a '<a> b <c>', corrisponderà all’intera stringa, e non solo a '<a>'. L’aggiunta di ? dopo il qualificatore fa sì che l’abbinamento avvenga in modo non avido o minimo; saranno abbinati il minor numero possibile di caratteri. Usando la RE <.*?> corrisponderà solo a '<a>'.

{m}

Specifica che esattamente m copie della precedente RE dovrebbero essere abbinate; poche copie fanno sì che l’intera RE non venga abbinata. Per esempio, a{6} corrisponderà esattamente a sei caratteri 'a', ma non a cinque.

{m,n}

Fa sì che l’RE risultante corrisponda da m a n ripetizioni dell’RE precedente, cercando di far corrispondere quante più ripetizioni possibili. Per esempio, a{3,5} corrisponderà da 3 a 5 caratteri 'a'. Omettendo m si specifica un limite inferiore di zero, e omettendo n si specifica un limite superiore infinito. Per esempio, a{4,}b corrisponderà a 'aaaab' o a mille 'a' caratteri seguiti da un 'b', ma non a 'aaab'. La virgola non può essere omessa o il modificatore verrebbe confuso con la forma precedentemente descritta.

{m,n}?

Fa sì che l’RE risultante corrisponda da m a n ripetizioni dell’RE precedente, cercando di corrispondere al minor numero possibile di ripetizioni. Questa è la versione on-greedy del precedente qualificatore. Per esempio, sulla stringa di 6 caratteri 'aaaaaa', a{3,5} corrisponderà a 5 caratteri 'a', mentre a{3,5}? corrisponderà solo a 3 caratteri.

\

Esclude i caratteri speciali (permettendovi di abbinare caratteri come'*', '?', e così via), o segnala una sequenza speciale; le sequenze speciali sono discusse più avanti.

Se non state usando una stringa grezza per esprimere il modello, ricordate che Python usa anche il backslash come sequenza di escape nei letterali di stringa; se la sequenza di escape non è riconosciuta dal parser di Python, il backslash e il carattere successivo sono inclusi nella stringa risultante. Tuttavia, se Python riconoscesse la sequenza risultante, il backslash dovrebbe essere ripetuto due volte. Questo è complicato e difficile da capire, quindi è altamente raccomandato che voi usiate stringhe di tipo “w” per tutte le espressioni tranne le più semplici.

Usato per indicare un insieme di caratteri. In un insieme:

• I caratteri possono essere elencati singolarmente, ad esempio corrisponderà a 'a','m', o 'k'.

• Gruppi di caratteri possono essere indicati dando due caratteri e separandoli con un '-', per esempio corrisponderà a qualsiasi lettera ASCII minuscola, corrisponderà a tutti i numeri di due cifre da 00 a 59, e corrisponderà a qualsiasi cifra esadecimale. Se - è sotto escape (es. ) o se è posto come primo o ultimo carattere (es. o ), corrisponderà a un letterale '-'.

• I caratteri speciali perdono il loro significato speciale all’interno dei set. Per esempio, corrisponderà a qualsiasi carattere letterale '(', '+','*', o ')'.

• Le classi di caratteri come \w o \S (definite sotto) sono anche accettate all’interno di un set, sebbene i caratteri che corrispondono dipendano dalla modalitàASCII o LOCALE in vigore.

• I caratteri che non sono in un intervallo possono essere abbinati completando l’insieme. Se il primo carattere dell’insieme è '^', tutti i caratteri che non sono nell’insieme saranno abbinati. Per esempio, corrisponderà a qualsiasi carattere eccetto '5', e corrisponderà a qualsiasi carattere eccetto '^'. ^ non ha un significato speciale se non è il primo carattere dell’insieme.

• Per abbinare un ']' letterale all’interno di un insieme, precedetelo con una barra rovesciata, o mettetelo all’inizio dell’insieme. Per esempio, sia {}] che() corrisponderanno entrambi ad una parentesi.

• Il supporto di insiemi annidati e operazioni di insiemi come in Unicode TechnicalStandard #18 potrebbe essere aggiunto in futuro. Questo cambierebbe la sintassi, quindi per facilitare questo cambiamento un FutureWarning sarà sollevato nei casi ambigui per il momento.Questo include gli insiemi che iniziano con un letterale '.

  (...)

  Corregge qualsiasi espressione regolare sia dentro le parentesi, e indica l’inizio e la fine di un gruppo; il contenuto di un gruppo può essere recuperato dopo che è stata eseguita una corrispondenza, e può essere abbinato successivamente nella stringa con la sequenza speciale \number, descritta sotto. Per abbinare i letterali '(' o ')', usate \( o \), o racchiudeteli in una classe di caratteri: , .

  (?...)

  Questa è una notazione di estensione (un '?' che segue un '(' non ha senso altrimenti). Il primo carattere dopo il '?' determina il significato e l’ulteriore sintassi del costrutto. Le estensioni di solito non creano un nuovo gruppo; (?P<name>...) è l’unica eccezione a questa regola. Seguono le estensioni attualmente supportate.

  (?aiLmsux)

  (Una o più lettere dall’insieme 'a', 'i', 'L', 'm','s', 'u', 'x'.) Il gruppo corrisponde alla stringa vuota; le lettere impostano le bandiere corrispondenti: re.A (corrispondenza solo ASCII),re.I (ignora le maiuscole), re.L (dipende dal locale),re.M (multilinea), re.S (il punto corrisponde a tutto),re.U (corrispondenza Unicode), e re.X (verboso), per l’intera espressione regolare.(Le bandiere sono descritte in Module Contents.)Questo è utile se si desidera includere le bandiere come parte dell’espressione regolare, invece di passare un argomento bandiera alla funzionere.compile(). I flag dovrebbero essere usati per primi nella stringa dell’espressione.

  (?:...)

  Una versione non catturante delle parentesi regolari. Corrisponde a qualsiasi espressione regolare si trovi all’interno delle parentesi, ma la sottostringa a cui corrisponde il gruppo non può essere recuperata dopo aver eseguito una corrispondenza o riferita successivamente nel modello.

  (?aiLmsux-imsx:...)

  (Zero o più lettere dall’insieme 'a', 'i', 'L', 'm','s', 'u', 'x', opzionalmente seguito da '-' seguito da una o più lettere dall’insieme 'i', 'm', 's', 'x'.Le lettere impostano o rimuovono i flag corrispondenti: re.A (corrispondenza solo ASCII), re.I (ignora le maiuscole), re.L (dipende dal locale), re.M (multilinea), re.S (punto corrisponde a tutto), re.U (corrispondenza Unicode) e re.X (verboso), per la parte dell’espressione.(I flag sono descritti in Module Contents.)

  Le lettere 'a', 'L' e 'u' si escludono a vicenda quando sono usati come flag in linea, quindi non possono essere combinati o seguire '-'. Invece, quando uno di loro appare in un gruppo in linea, sovrascrive la modalità di corrispondenza nel gruppo che lo racchiude. Nei pattern Unicode (?a:...) passa alla corrispondenza ASCII-only, e (?u:...) passa alla corrispondenza Unicode (default). Nei pattern byte (?L:...) passa alla corrispondenza dipendente dal locale, e (?a:...) passa alla corrispondenza ASCII-only (predefinita). Questa sovrapposizione è in vigore solo per il gruppo inline stretto, e la modalità di corrispondenza originale viene ripristinata al di fuori del gruppo.

  Nuovo nella versione 3.6.

  Cambiato nella versione 3.7: Anche le lettere 'a', 'L' e 'u' possono essere usate in un gruppo.

  (?P<name>...)

  Simile alle parentesi regolari, ma la sottostringa abbinata al gruppo è accessibile tramite il nome simbolico del gruppo. I nomi dei gruppi devono essere identificatori Python validi, e ogni nome di gruppo deve essere definito solo una volta all’interno di un’espressione regolare. Un gruppo simbolico è anche un gruppo numerato, proprio come se il gruppo non avesse un nome.

  I gruppi con nome possono essere referenziati in tre contesti. Se il modello è(?P<quote>).*?(?P=quote) (cioè corrisponde a una stringa citata con apici singoli o doppi):

  Contesto di riferimento al gruppo “quote”	Come fare riferimento ad esso
  nello stesso pattern	(?P=quote) (come mostrato)
  nell’elaborazione dell’oggetto match m	m.group('quote') m.end('quote') (ecc.)
  in una stringa passata al replargument di re.sub()	\g<quote> \g<1>

  (?P=name)

  Un backreference a un gruppo nominato; corrisponde a qualsiasi testo a cui corrispondeva il nome del gruppo precedente.

  (?#...)

  Un commento; il contenuto delle parentesi viene semplicemente ignorato.

  (?=...)

  Cambia se ... corrisponde al successivo, ma non consuma alcuna stringa. Questa è chiamata un’asserzione lookahead. Per esempio, Isaac (?=Asimov) corrisponderà a'Isaac ' solo se è seguito da 'Asimov'.

  (?!...)

  Compare se ... non corrisponde al prossimo. Per esempio, Isaac (?!Asimov) corrisponderà a 'Isaac ' solo se non è seguito da 'Asimov'.

  (?<=...)

  Cambia se la posizione corrente nella stringa è preceduta da una corrispondenza per ...che finisce nella posizione corrente. Questo è chiamato lookbehindassertion positivo. (?<=abc)def troverà una corrispondenza in 'abcdef', dal momento che il lookbehind arretrerà di 3 caratteri e controllerà se il pattern contenuto corrisponde.Il pattern contenuto deve corrispondere solo a stringhe di una certa lunghezza fissa, il che significa cheabc o a|b sono ammessi, ma a* e a{3,4} non lo sono. Si noti che gli schemi che iniziano con asserzioni lookbehind positive non corrisponderanno all’inizio della stringa da cercare; è molto probabile che si voglia usare la funzionesearch() piuttosto che la funzione match():

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

  Questo esempio cerca una parola dopo un trattino:

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

  Cambiato nella versione 3.5: Aggiunto il supporto per i riferimenti di gruppo di lunghezza fissa.

  (?<!...)

  Cambia se la posizione corrente nella stringa non è preceduta da una corrispondenza per.... Questa è chiamata un’asserzione lookbehind negativa. Simile alle asserzioni lookbehind positive, il pattern contenuto deve corrispondere solo a stringhe di una certa lunghezza fissa. Gli schemi che iniziano con asserzioni lookbehind negative possono corrispondere all’inizio della stringa da cercare.

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

  Tenterà di corrispondere con yes-pattern se il gruppo con id o nome dato esiste, e con no-pattern se non esiste. no-pattern è facoltativo e può essere omesso. Per esempio, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) è un modello di corrispondenza e-mail povero, che corrisponderà a '<[email protected]>' come pure a '[email protected]', ma non a '<[email protected]' né a '[email protected]>'.

  Le sequenze speciali consistono di '\' e di un carattere dalla lista sottostante; se il carattere ordinario non è una cifra ASCII o una lettera ASCII, allora l’RE risultante corrisponderà al secondo carattere. Per esempio, $ corrisponde al carattere '$'.

  \number

  Cambia il contenuto del gruppo dello stesso numero. I gruppi sono numerati a partire da 1. Per esempio, (.+) corrisponde a 'the the' o '55 55', ma non a 'thethe' (notare lo spazio dopo il gruppo). Questa sequenza speciale può essere usata solo per abbinare uno dei primi 99 gruppi. Se la prima cifra del numero è 0, o il numero è lungo 3 cifre ottali, non sarà interpretato come una corrispondenza di gruppo, ma come il carattere con valore ottale numero. All’interno del'' di una classe di caratteri, tutti gli escape numerici sono trattati come caratteri.

  \A

  Compare solo all’inizio della stringa.

  \b

  Compare la stringa vuota, ma solo all’inizio o alla fine di una parola.Una parola è definita come una sequenza di caratteri parola. Si noti che formalmente, \b è definito come il confine tra un carattere \w e uno \W (o viceversa), o tra \w e l’inizio/fine della stringa.Questo significa che r'\bfoo\b' corrisponde a 'foo', 'foo.', '(foo)','bar foo baz' ma non a 'foobar' o 'foo3'.

  Di default gli alfanumerici Unicode sono quelli usati nei pattern Unicode, ma questo può essere cambiato usando il flag ASCII. I confini delle parole sono determinati dal locale corrente se viene usato il flag LOCALE.All’interno di un intervallo di caratteri, \b rappresenta il carattere backspace, per compatibilità con i letterali di stringa di Python.

  \B

  Corregge la stringa vuota, ma solo quando non è all’inizio o alla fine di una parola. Questo significa che r'py\B' corrisponde a 'python', 'py3','py2', ma non a 'py', 'py.', o 'py!'.\B è proprio l’opposto di \b, quindi i caratteri di parola in Unicodepatterns sono alfanumerici Unicode o il trattino basso, sebbene questo possa essere cambiato usando il flag ASCII. I confini delle parole sono determinati dal locale corrente se viene usato il flag LOCALE.

  \d Per i pattern Unicode (str):

  Corregge qualsiasi cifra decimale Unicode (cioè, qualsiasi carattere nella categoria dei caratteri Unicode). Questo include , e anche molti altri caratteri numerici. Se il flag ASCII viene usato solo viene abbinato.

  Per modelli a 8 bit (byte):

  Cerca qualsiasi cifra decimale; questo è equivalente a .

  \D

  Cerca qualsiasi carattere che non sia una cifra decimale. Questo è l’opposto di \d. Se viene usato il flag ASCII questo diventa l’equivalente di .

  \s Per i pattern Unicode (str):

  Corregge i caratteri di spazio bianco Unicode (che include, e anche molti altri caratteri, per esempio gli spazi non interrotti richiesti dalle regole tipografiche in molte lingue). Se viene usato il flag ASCII, solo viene abbinato.

  Per modelli a 8 bit (byte):

  Comprende i caratteri considerati spazi bianchi nel set di caratteri ASCII; questo è equivalente a .

  \S

  Comprende qualsiasi carattere che non sia uno spazio bianco. Questo è l’opposto di \s. Se viene usato il flag ASCII questo diventa l’equivalente di .

  \w Per i pattern Unicode (str):

  Corregge i caratteri di parola Unicode; questo include la maggior parte dei caratteri che possono essere parte di una parola in qualsiasi lingua, così come i numeri e l’underscore. Se viene usato il flag ASCII, solo viene abbinato.

  Per modelli a 8 bit (byte):

  Comprende i caratteri considerati alfanumerici nel set di caratteri ASCII; questo è equivalente a . Se viene usato il flag LOCALE, corrisponde ai caratteri considerati alfanumerici nel locale corrente e al trattino basso.

  \W

  Cerca qualsiasi carattere che non sia una parola. Questo è il contrario di \w. Se viene usato il flag ASCII questo diventa l’equivalente di . Se viene usato il flag LOCALE, corrisponde ai caratteri che non sono né alfanumerici nell’attuale locale né il trattino basso.

  \Z

  Corre solo alla fine della stringa.

  La maggior parte degli escape standard supportati dai letterali di stringa Python sono anche accettati dall’analizzatore di espressioni regolari:

  \a \b \f \n\N \r \t \u\U \v \x \

  (Si noti che \b è usato per rappresentare i confini delle parole, e significa “backspace” solo all’interno delle classi di caratteri.)

  '\u', '\U', e '\N' sequenze di escape sono riconosciute solo negli Unicodepattern. Nei modelli byte sono errori. Gli escape sconosciuti di lettere ASCII sono riservati per uso futuro e trattati come errori.

  Gli escape ottali sono inclusi in una forma limitata. Se la prima cifra è uno 0, o se ci sono tre cifre ottali, è considerato un escape ottale. Altrimenti, è un riferimento di gruppo. Come per i letterali di stringa, gli escape ottali hanno sempre al massimo tre cifre di lunghezza.

  Cambiato nella versione 3.3: Sono state aggiunte le sequenze di escape '\u' e '\U'.

  Cambiato nella versione 3.6: Gli escape sconosciuti composti da '\' e una lettera ASCII ora sono errori.

  Cambiato nella versione 3.8: È stata aggiunta la sequenza di escape '\N{name}'. Come nei letterali di stringa, si espande al carattere Unicode nominato (ad esempio '\N{EM DASH}').