2.36. Grupper och ankare

Ett mönster kan göra mer än att säga ”den här strängen matchar” – det kan plocka isär de matchade delarna och överlämna var och en till applikationen med namn. Parenteser runt en del av ett mönster gör den till en fångstgrupp; matchobjektet exponerar sedan varje grupp som en separat delsträng.

2.36.1. Fångstgrupper

Omslut valfri del av ett mönster med (...) för att fånga det som matchade:

>>> 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'

  • Grupp 0 är alltid hela matchningen.

  • Grupp 1, 2, … är de fångade delsträngarna, numrerade från vänster till höger efter sin öppnande parentes.

  • Att anropa match.group() med ett index efter den sista gruppen ger upphov till IndexError.

Ett vanligt mönster är ”matcha en känd struktur, fånga de variabla delarna som heltal”:

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. Icke-fångande grupper

Parenteser grupperar också ett deluttryck så att en kvantifierare kan tillämpas på hela gruppen. Det är det enda syftet med grupperingen i r'(ab)+' – ”en eller flera av ab”. Att ab dyker upp som grupp 1 är en bieffekt.

För att gruppera utan att fånga, använd (?:...)

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

Icke-fångande grupper håller gruppnumren snygga när ett mönster använder gruppering för struktur men inte bryr sig om att plocka ut varje del.

2.36.3. Ankare

Ankare matchar inte ett tecken – de matchar en position.

  • ^ – början av strängen.

  • $ – slutet av strängen.

Ankare är det som gör att re.match() och re.search() beter sig olika. re.match(p, s) är samma sak som re.search('^' + p, s): det tvingar mönstret att börja vid position 0. Att lägga till $ i slutet av ett mönster gör sedan att mönstret matchar hela strängen och inget annat:

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

^ och $ i MicroPython re betyder alltid början och slutet av hela strängen som skickas till re.search(). Det finns ingen re.MULTILINE-flagga som får dem att matcha vid varje inbäddad radbrytning, och $ matchar inte heller positionen före en avslutande \n – det måste vara det absoluta slutet av indata. För att få radvis beteende, dela först upp indata på radbrytningar och kör mönstret på varje rad.

2.36.4. Teckenuppsättningar

Hakparenteser definierar en explicit uppsättning tecken. Matchningen förbrukar exakt ett tecken från uppsättningen.

  • [abc] – en av a, b, c.

  • [a-z] – ett tecken i intervallet a-z (inklusive).

  • [a-zA-Z0-9] – bokstäver eller siffror. Tre intervall kombinerade.

  • [^abc] – inte en av a, b, c. ^ negerar endast när det är det första tecknet inuti hakparenteserna.

Exempel:

>>> 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

Det första anropet returnerar i praktiken None eftersom den bokstavliga texten är gemener. MicroPython re har ingen re.IGNORECASE-flagga – för att matcha skiftlägesokänsligt, skriv in båda skiftlägena i uppsättningen:

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

Klassgenvägarna (\d, \s, \w och deras negerade former) kan också användas inuti [...]: [\w-] betyder ”ordtecken eller ett bokstavligt bindestreck.”

2.36.5. Giriga kontra lata kvantifierare

Kvantifierarna *, +, ? och {m,n} är giriga som standard – de matchar så många tecken som resten av mönstret fortfarande tillåter. Ofta är det precis vad som önskas; ibland är det inte det:

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

Den giriga .+ tog hela vägen fram till det sista >. Att lägga till ? gör kvantifieraren lat – den matchar så lite som möjligt:

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

Den lata formen stannar vid det första >. Lata kvantifierare dyker ständigt upp när man extraherar balanserade avgränsare från en sträng.

2.36.6. Bakåtreferenser i substitution

re.sub() kan referera tillbaka till fångade grupper i ersättningssträngen via \1, \2, … Substitutionen skriver om varje matchning med hjälp av de fångade delarna:

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

Varje matchning fångar två tal, och ersättningen byter plats på dem. \g<1> är en alternativ syntax för samma sak – användbart när nästa tecken i ersättningen är en siffra (r'\g<1>0' för att lägga till en bokstavlig nolla efter grupp 1 i stället för att läsa ”grupp 10”).

2.36.7. Vad som inte är tillgängligt

En påminnelse om vad MicroPython re inte stöder, ifall ett mönster från CPython hamnar här och överraskar dig:

  • Framåtblick (?=...) och bakåtblick (?<=...) – inte implementerade.

  • Namngivna grupper (?P<name>...) och namngivna bakåtreferenser (?P=name) – inte implementerade.

  • Flaggkonstanter som re.IGNORECASE, re.MULTILINE, re.DOTALL – respekteras inte. Bygg själv den skiftlägesokänsliga uppsättningen eller dela upp indata i förväg.

  • Metoderna match.groups(), match.span(), match.start() och match.end() är spärrade på en ROM-nivå som inget levererat OpenMV-kort aktiverar. Kod som förlitar sig på dem kör inte på kameran.

Med mönster, grupper och ankare är regex-verktygslådan på kameran tillräckligt liten för att lära sig i ett svep och tillräckligt rik för att göra allt utom kontextkänslig parsning.