2.36. Gruppi e ancore

Un pattern può fare di più che dire «questa stringa corrisponde»: può scomporre le parti trovate e passarne ognuna all’applicazione tramite un nome. Le parentesi attorno a una porzione di un pattern la rendono un gruppo di cattura; il match object espone quindi ogni gruppo come una sottostringa separata.

2.36.1. Gruppi di cattura

Racchiudi una qualsiasi porzione di un pattern tra (...) per catturare ciò che ha trovato:

>>> import re
>>> m = re.search(r'temp (\d+) at (\d+)s', 'temp 42 at 137s ok')
>>> m.group(0)
'temp 42 at 137s'
>>> m.group(1)
'42'
>>> m.group(2)
'137'

  • Il gruppo 0 è sempre l’intera corrispondenza.

  • I gruppi 1, 2, … sono le sottostringhe catturate, numerate da sinistra a destra in base alla loro parentesi di apertura.

  • Chiamare match.group() con un indice oltre l’ultimo gruppo solleva IndexError.

Un pattern comune è «trova una struttura nota, cattura le parti variabili come interi»:

def parse_temp(line):
    m = re.search(r'temp (\d+) at (\d+)s', line)
    if not m:
        return None
    return int(m.group(1)), int(m.group(2))

2.36.2. Gruppi senza cattura

Le parentesi raggruppano anche una sotto-espressione, in modo che un quantificatore possa applicarsi all’intero gruppo. È questo l’unico scopo del raggruppamento in r'(ab)+': «uno o più ab«. Il fatto che ab compaia come gruppo 1 è un effetto collaterale.

Per raggruppare senza catturare, usa (?:...)

>>> re.search(r'(?:ab)+', 'xababy').group(0)
'abab'

I gruppi senza cattura mantengono ordinata la numerazione dei gruppi quando un pattern usa il raggruppamento per la struttura ma non ha bisogno di estrarre ogni singola parte.

2.36.3. Ancore

Le ancore non corrispondono a un carattere: corrispondono a una posizione.

  • ^ – inizio della stringa.

  • $ – fine della stringa.

Le ancore sono ciò che fa comportare diversamente re.match() e re.search(). re.match(p, s) equivale a re.search('^' + p, s): forza il pattern a iniziare alla posizione 0. Aggiungere $ alla fine di un pattern fa quindi sì che il pattern corrisponda all”intera stringa e a nient’altro:

>>> re.search(r'^\d+$', '12345')
<match num=1>
>>> re.search(r'^\d+$', '12345 ok') is None
True

In MicroPython re, ^ e $ indicano sempre l’inizio e la fine dell”intera stringa passata a re.search(). Non esiste un flag re.MULTILINE per farli corrispondere a ogni newline interno, e $ non corrisponde nemmeno alla posizione prima di un \n finale: deve essere la fine assoluta dell’input. Per ottenere un comportamento per riga, dividi prima l’input sui newline ed esegui il pattern su ogni riga.

2.36.4. Insiemi di caratteri

Le parentesi quadre definiscono un insieme esplicito di caratteri. La corrispondenza consuma esattamente un carattere dell’insieme.

  • [abc] – uno tra a, b, c.

  • [a-z] – un carattere nell’intervallo a-z (estremi inclusi).

  • [a-zA-Z0-9] – lettere o cifre. Tre intervalli combinati.

  • [^abc] – non uno tra a, b, c. Il ^ nega solo quando è il primo carattere all’interno delle parentesi.

Esempi:

>>> re.search(r'[A-F0-9]{6}', 'colour #1a2b3c rest').group(0)
'1A2B3C'
>>> re.search(r'[A-F0-9]{6}', 'colour #1a2b3c rest') is None
True

In pratica la prima chiamata restituisce None perché il testo letterale è in minuscolo. MicroPython re non ha alcun flag re.IGNORECASE: per una corrispondenza che ignori le maiuscole/minuscole, inserisci entrambe le forme nell’insieme:

>>> re.search(r'[A-Fa-f0-9]{6}', 'colour #1a2b3c rest').group(0)
'1a2b3c'

Le scorciatoie di classe (\d, \s, \w e le loro forme negate) possono essere usate anche dentro [...]: [\w-] significa «caratteri di parola o un trattino letterale».

2.36.5. Quantificatori greedy e lazy

I quantificatori *, +, ? e {m,n} sono greedy per impostazione predefinita: corrispondono a quanti più caratteri possibile pur lasciando che il resto del pattern continui a corrispondere. Spesso è esattamente ciò che si vuole; a volte no:

>>> re.search(r'<(.+)>', 'a <b> <c> d').group(1)
'b> <c'

Il .+ greedy ha catturato fino all’ultimo >. Aggiungere ? rende il quantificatore lazy: corrisponde a quanto meno possibile:

>>> re.search(r'<(.+?)>', 'a <b> <c> d').group(1)
'b'

La forma lazy si ferma al primo >. I quantificatori lazy ricorrono di continuo quando si estraggono delimitatori bilanciati da una stringa.

2.36.6. Backreference nella sostituzione

re.sub() può riferirsi ai gruppi catturati nella stringa di sostituzione tramite \1, \2, … La sostituzione riscrive ogni corrispondenza usando le parti catturate:

>>> re.sub(r'(\d+)\.(\d+)', r'\2.\1', 'swap 12.34 and 5.6')
'swap 34.12 and 6.5'

Ogni corrispondenza cattura due numeri e la sostituzione li scambia. \g<1> è una sintassi alternativa per la stessa cosa, utile quando il carattere successivo nella sostituzione è una cifra (r'\g<1>0' per aggiungere uno zero letterale al gruppo 1 invece di leggere «gruppo 10»).

2.36.7. Cosa non è disponibile

Un promemoria di ciò che MicroPython re non supporta, nel caso un pattern proveniente da CPython finisca qui e ti sorprenda:

  • Lookahead (?=...) e lookbehind (?<=...) – non implementati.

  • Gruppi con nome (?P<name>...) e backreference con nome (?P=name) – non implementati.

  • Costanti flag come re.IGNORECASE, re.MULTILINE, re.DOTALL – non rispettate. Costruisci tu stesso l’insieme insensibile alle maiuscole o pre-suddividi l’input.

  • I metodi match.groups(), match.span(), match.start() e match.end() sono vincolati a un livello ROM che nessuna scheda OpenMV in commercio abilita. Il codice che vi fa affidamento non funzionerà sulla cam.

Con pattern, gruppi e ancore, il set di strumenti per le regex sulla cam è abbastanza piccolo da imparare in una sola seduta e abbastanza ricco da fare tutto, tranne il parsing sensibile al contesto.