re — Operationer med reguljära uttryck

Källkod: Lib/re/


Den här modulen innehåller funktioner för matchning med reguljära uttryck som liknar dem som finns i Perl.

Både mönster och strängar som ska sökas kan vara Unicode-strängar (str) såväl som 8-bitarssträngar (bytes). Unicode-strängar och 8-bitarssträngar kan dock inte blandas: det vill säga, du kan inte matcha en Unicode-sträng med ett bytesmönster eller vice versa; på samma sätt måste ersättningssträngen vara av samma typ som både mönstret och söksträngen när du ber om en substitution.

Reguljära uttryck använder tecknet backslash ('\') för att ange speciella former eller för att tillåta att specialtecken används utan att deras speciella betydelse åberopas. Detta kolliderar med Pythons användning av samma tecken för samma ändamål i stränglitteraler; till exempel, för att matcha en bokstavlig backslash kan man behöva skriva '\\\\' som mönstersträng, eftersom det reguljära uttrycket måste vara \, och varje backslash måste uttryckas som \\ inuti en reguljär Python-stränglitteral. Observera också att alla ogiltiga escape-sekvenser i Pythons användning av backslash i stränglitteraler nu genererar en SyntaxWarning och i framtiden kommer detta att bli en SyntaxError. Detta beteende kommer att ske även om det är en giltig escape-sekvens för ett reguljärt uttryck.

Lösningen är att använda Pythons råa strängnotation för reguljära uttrycksmönster; backslash hanteras inte på något speciellt sätt i en stränglitual med prefixet 'r'. Så r"\n" är en tvåteckenssträng som innehåller '\' och 'n', medan "\n" är en enteckenssträng som innehåller en ny rad. Vanligtvis kommer mönster att uttryckas i Python-kod med hjälp av denna råa strängnotation.

Det är viktigt att notera att de flesta operationer med reguljära uttryck finns tillgängliga som funktioner och metoder på modulnivå på compiled regular expressions. Funktionerna är genvägar som inte kräver att du först kompilerar ett regex-objekt, men saknar vissa finjusteringsparametrar.

Se även

Tredjepartsmodulen regex, som har ett API som är kompatibelt med standardbibliotekets modul re, men som erbjuder ytterligare funktionalitet och ett mer omfattande Unicode-stöd.

Syntax för reguljära uttryck

Ett reguljärt uttryck (eller RE) anger en uppsättning strängar som matchar det; med funktionerna i den här modulen kan du kontrollera om en viss sträng matchar ett visst reguljärt uttryck (eller om ett visst reguljärt uttryck matchar en viss sträng, vilket är samma sak).

Reguljära uttryck kan sammankopplas för att bilda nya reguljära uttryck; om A och B båda är reguljära uttryck, är AB också ett reguljärt uttryck. I allmänhet gäller att om en sträng p matchar A och en annan sträng q matchar B, kommer strängen pq att matcha AB. Detta gäller om inte A eller B innehåller operationer med låg prioritet, gränsvillkor mellan A och B eller har numrerade gruppreferenser. Komplexa uttryck kan alltså lätt konstrueras från enklare primitiva uttryck som de som beskrivs här. För detaljer om teorin och implementeringen av reguljära uttryck, se Friedls bok [Frie09], eller nästan vilken lärobok som helst om kompilatorkonstruktion.

Här följer en kort förklaring av formatet för reguljära uttryck. För ytterligare information och en mildare presentation, se Reguljära uttryck HOWTO.

Reguljära uttryck kan innehålla både specialtecken och vanliga tecken. De flesta vanliga tecken, som 'A', 'a' eller '0', är de enklaste reguljära uttrycken; de matchar helt enkelt sig själva. Du kan konkatenera vanliga tecken, så att last matchar strängen 'last'. (I resten av det här avsnittet skriver vi RE:s med den här speciella stilen, vanligtvis utan citationstecken, och strängar som ska matchas 'med enkla citationstecken)

Vissa tecken, som '|' eller '(', är specialtecken. Specialtecken står antingen för klasser av vanliga tecken eller påverkar hur de reguljära uttryck som omger dem tolkas.

Repetitionsoperatorer eller kvantifierare (*, +, ?, {m,n}, etc) kan inte direkt nästlas. Detta undviker tvetydighet med det icke-greedy modifieringssuffixet ?, och med andra modifierare i andra implementeringar. För att tillämpa en andra upprepning på en inre upprepning kan parenteser användas. Till exempel matchar uttrycket (?:a{6})* alla multiplar av sex 'a'-tecken.

Specialtecknen är följande:

.

(Punkt.) I standardläget matchar detta alla tecken utom en ny rad. Om flaggan DOTALL har angetts, matchar detta alla tecken inklusive en ny rad. (?s:.) matchar alla tecken oavsett flaggor.

^

(Caret.) Matchar början av strängen, och i MULTILINE-läget även omedelbart efter varje ny rad.

$

Matchar slutet av strängen eller precis före den nya raden i slutet av strängen, och i MULTILINE-läget även före en ny rad. foo matchar både ’foo’ och ’foobar’, medan det reguljära uttrycket foo$ endast matchar ’foo’. Mer intressant är att en sökning efter foo.$ i 'foo1\nfoo2\n' normalt matchar ’foo2’, men ’foo1’ i MULTILINE-läget; en sökning efter en enda $ i 'foo\n' kommer att hitta två (tomma) träffar: en precis före det nya strecket och en i slutet av strängen.

*

Gör att den resulterande RE:n matchar 0 eller flera upprepningar av den föregående RE:n, så många upprepningar som möjligt. ab* matchar ’a’, ’ab’ eller ’a’ följt av ett valfritt antal ’b’.

+

Gör att den resulterande RE:n matchar 1 eller flera upprepningar av den föregående RE:n. ab+ kommer att matcha ’a’ följt av ett valfritt antal ’b’ som inte är noll; det kommer inte att matcha bara ’a’.

?

Gör att den resulterande RE:n matchar 0 eller 1 upprepningar av den föregående RE:n. ab? kommer att matcha antingen ’a’ eller ’ab’.

*?, +?, ??

Kvantifierarna '*', '+' och '?' är alla greedy; de matchar så mycket text som möjligt. Ibland är detta beteende inte önskvärt; om RE <.*> matchas mot '<a> b <c>', kommer den att matcha hela strängen, och inte bara '<a>'. Om du lägger till ? efter kvantifieraren kommer den att utföra matchningen på non-greedy eller minimal sätt; så tecken som möjligt kommer att matchas. Om RE <.*?> används kommer endast '<a>' att matchas.

*+, ++, ?+

Liksom kvantifierarna '*', '+' och '?' matchar de där '+' är tillagt också så många gånger som möjligt. Men till skillnad från de riktiga greedy-kvantifierarna tillåter dessa inte backspårning när uttrycket efter det inte matchar. Dessa är kända som possessiva kvantifierare. Till exempel kommer a*a att matcha 'aaaa' eftersom a* kommer att matcha alla 4 'a' s, men när den sista 'a' påträffas, spåras uttrycket tillbaka så att a* i slutändan matchar 3 'a' s totalt, och den fjärde 'a' matchas av den sista 'a'. Men när a*+a används för att matcha 'aaaa' kommer a*+ att matcha alla fyra 'a', men när den sista 'a' inte hittar några fler tecken att matcha kan uttrycket inte spåras tillbaka och kommer därför inte att matcha. x*+, x++ och x?+ är likvärdiga med (?>x*), (?>x+) och (?>x?) på motsvarande sätt.

Tillagd i version 3.11.

{m}

Anger att exakt m kopior av föregående RE ska matchas; färre matchningar gör att hela RE inte matchas. Till exempel kommer a{6} att matcha exakt sex 'a'-tecken, men inte fem.

{m,n}

Gör att den resulterande RE:n matchar från m till n upprepningar av den föregående RE:n, med försök att matcha så många upprepningar som möjligt. Exempelvis kommer a{3,5} att matcha mellan 3 och 5 'a'-tecken. Om m utelämnas anges en nedre gräns på noll, och om n utelämnas anges en oändlig övre gräns. Som ett exempel kommer a{4,}b att matcha 'aaaab' eller tusen 'a'-tecken följt av ett 'b', men inte 'aaab'. Kommatecknet får inte utelämnas, eftersom modifieraren då skulle förväxlas med den tidigare beskrivna formen.

{m,n}?

Gör att den resulterande RE:n matchar från m till n repetitioner av föregående RE, med försök att matcha så repetitioner som möjligt. Detta är den icke-grådiga versionen av den föregående kvantifieraren. Till exempel, på strängen 'aaaaaa' med 6 tecken kommer a{3,5} att matcha 5 'a'-tecken, medan a{3,5}? endast kommer att matcha 3 tecken.

{m,n}+

Gör att den resulterande RE:n matchar från m till n upprepningar av föregående RE, med försök att matcha så många upprepningar som möjligt utan att skapa några backtracking-punkter. Detta är den possessiva versionen av kvantifieraren ovan. Till exempel, på strängen 'aaaaaa' med 6 tecken, försöker a{3,5}+aa matcha 5 'a'-tecken, sedan, när ytterligare 2 'a'-tecken krävs, behöver fler tecken än tillgängliga och misslyckas därför, medan a{3,5}aa kommer att matcha med a{3,5} som fångar 5, sedan 4 'a'-tecken genom backtracking och sedan matchas de sista 2 'a'-tecken av den sista aa i mönstret. x{m,n}+ är likvärdigt med (?>x{m,n}).

Tillagd i version 3.11.

\

Antingen undviker du specialtecken (så att du kan matcha tecken som '*', '?' osv.) eller så signalerar du en specialsekvens; specialsekvenser diskuteras nedan.

Om du inte använder en rå sträng för att uttrycka mönstret, kom ihåg att Python också använder backslash som en escape-sekvens i stränglitteraler; om escape-sekvensen inte känns igen av Pythons parser, inkluderas backslash och efterföljande tecken i den resulterande strängen. Men om Python skulle känna igen den resulterande sekvensen, bör backslash upprepas två gånger. Det här är komplicerat och svårt att förstå, så det rekommenderas starkt att du använder råa strängar för alla utom de enklaste uttrycken.

[]

Används för att ange en uppsättning tecken. I en uppsättning:

  • Tecken kan listas individuellt, t.ex. kommer [amk] att matcha 'a', 'm' eller 'k'.

  • Teckenintervall kan anges genom att ange två tecken och separera dem med '-', t.ex. [a-z] matchar alla gemena ASCII-bokstäver, [0-5][0-9] matchar alla tvåsiffriga tal från 00 till 59 och [0-9A-Fa-f] matchar alla hexadecimala siffror. Om - är escapat (t.ex. [a\ -z]) eller om det placeras som första eller sista tecken (t.ex. [-a] eller [a-]), kommer det att matcha ett bokstavligt '-'.

  • Specialtecken utom backslash förlorar sin speciella betydelse i uppsättningar. Till exempel kommer [(+*)] att matcha vilket som helst av de bokstavliga tecknen '(', '+', '*' eller ')'.

  • Backslash escapar antingen tecken som har en speciell betydelse i en uppsättning, t.ex. '-', ']', '^' och '\\', eller signalerar en speciell sekvens som representerar ett enskilt tecken, t.ex. xa0 eller n, eller en teckenklass, t.ex. w eller S (definieras nedan). Observera att b representerar ett enskilt ”backspace”-tecken, inte en ordgräns utanför en uppsättning, och numeriska escapes som 1 är alltid oktala escapes, inte gruppreferenser. Specialsekvenser som inte matchar ett enda tecken, t.ex. A och z, är inte tillåtna.

  • Tecken som inte finns inom ett intervall kan matchas genom att komplettera uppsättningen. Om det första tecknet i uppsättningen är '^' kommer alla tecken som inte finns i uppsättningen att matchas. Till exempel kommer [^5] att matcha alla tecken utom '5', och [^^] kommer att matcha alla tecken utom '^'. ^ har ingen speciell betydelse om det inte är det första tecknet i uppsättningen.

  • För att matcha en bokstavlig ']' inuti en uppsättning, föregå den med ett backslash eller placera den i början av uppsättningen. Till exempel kommer både [()[\]{}] och []()[{}] att matcha en högerparentes såväl som vänsterparenteser, hakparenteser och parenteser.

  • Stöd för nästlade mängder och mängdoperationer som i Unicode Technical Standard #18 kan komma att läggas till i framtiden. Detta skulle ändra syntaxen, så för att underlätta denna förändring kommer en FutureWarning att visas i tvetydiga fall för tillfället. Detta inkluderar uppsättningar som börjar med en bokstavlig '[' eller innehåller bokstavliga teckensekvenser '--', '&&', '~~' och '||'. För att undvika en varning, undvik dem med ett backslash.

Ändrad i version 3.7: FutureWarning utlöses om en teckenuppsättning innehåller konstruktioner som kommer att förändras semantiskt i framtiden.

|

A|B, där A och B kan vara godtyckliga RE:s, skapar ett reguljärt uttryck som matchar antingen A eller B. Ett godtyckligt antal RE:s kan separeras med '|' på detta sätt. Detta kan även användas inom grupper (se nedan). När målsträngen skannas testas RE:s som separerats med '|' från vänster till höger. När ett mönster matchar fullständigt accepteras den grenen. Detta innebär att när A matchar kommer B inte att testas ytterligare, även om det skulle ge en längre total matchning. Med andra ord är operatorn '|' aldrig girig. Om du vill matcha en bokstavlig '|' använder du \|` eller omsluter den i en teckenklass, som i ``[|].

(...)

Matchar det reguljära uttryck som finns inom parentesen och anger början och slutet på en grupp; innehållet i en grupp kan hämtas efter att en matchning har utförts och kan matchas senare i strängen med specialsekvensen \number, som beskrivs nedan. För att matcha bokstavstecken '(' eller ')', använd ( eller \), eller omslut dem i en teckenklass: [(], [)].

(?...)

Detta är en utvidgad notation (en '?' efter en '(' är inte meningsfull i övrigt). Det första tecknet efter '?' avgör vad konstruktionen har för betydelse och vidare syntax. Tillägg skapar vanligtvis inte en ny grupp; (?P<name>...) är det enda undantaget från denna regel. Följande är de tillägg som för närvarande stöds.

(?aiLmsux)

(En eller flera bokstäver från uppsättningen 'a', 'i', 'L', 'm', 's', 'u', 'x'.) Gruppen matchar den tomma strängen; bokstäverna anger motsvarande flaggor för hela det reguljära uttrycket:

  • re.A (endast ASCII-matchning)

  • re.I (ignorera fall)

  • re.L (lokalberoende)

  • re.M (flerradig)

  • re.S (prick matchar alla)

  • re.U (Unicode-matchning)

  • re.X (långsam)

(Flaggorna beskrivs i Modulens innehåll.) Detta är användbart om du vill inkludera flaggorna som en del av det reguljära uttrycket, istället för att skicka ett flag-argument till re.compile()-funktionen. Flaggorna bör användas först i uttryckssträngen.

Ändrad i version 3.11: Denna konstruktion kan endast användas i början av uttrycket.

(?:...)

En icke-fångande version av reguljära parenteser. Matchar det reguljära uttryck som finns inom parentesen, men den delsträng som matchas av gruppen kan inte hämtas efter en matchning eller refereras till senare i mönstret.

(?aiLmsux-imsx:...)

(Noll eller flera bokstäver från uppsättningen 'a', 'i', 'L', 'm', 's', 'u', 'x', eventuellt följt av '-' följt av en eller flera bokstäver från 'i', 'm', 's', 'x'.) Bokstäverna sätter eller tar bort motsvarande flaggor för den del av uttrycket:

  • re.A (endast ASCII-matchning)

  • re.I (ignorera fall)

  • re.L (lokalberoende)

  • re.M (flerradig)

  • re.S (prick matchar alla)

  • re.U (Unicode-matchning)

  • re.X (långsam)

(Flaggorna beskrivs i Modulens innehåll.)

Bokstäverna 'a', 'L' och 'u' är ömsesidigt uteslutande när de används som inline-flaggor, så de kan inte kombineras eller följa '-'. Istället, när en av dem visas i en inline-grupp, åsidosätter den matchningsläget i den omslutande gruppen. I Unicode-mönster växlar (?a:...) till enbart ASCII-matchning och (?u:...) växlar till Unicode-matchning (standard). I bytesmönster växlar (?L:...) till lokalberoende matchning och (?a:...) växlar till enbart ASCII-matchning (standard). Detta åsidosättande gäller endast för gruppen narrow inline, och det ursprungliga matchningsläget återställs utanför gruppen.

Tillagd i version 3.6.

Ändrad i version 3.7: Bokstäverna 'a', 'L' och 'u' kan också användas i en grupp.

(?>...)

Försöker matcha ... som om det vore ett separat reguljärt uttryck, och om det lyckas fortsätter det att matcha resten av det efterföljande mönstret. Om det efterföljande mönstret inte matchar kan stacken bara rullas tillbaka till en punkt före (?>...) eftersom uttrycket, som kallas en atomisk grupp, har kastat bort alla stackpunkter inom sig när det väl har avslutats. Således skulle (?>.*). aldrig matcha någonting eftersom först .* skulle matcha alla möjliga tecken, sedan, när det inte fanns något kvar att matcha, skulle den sista . misslyckas med att matcha. Eftersom det inte finns några stackpunkter sparade i Atomic Group, och det inte finns någon stackpunkt före den, skulle hela uttrycket alltså inte matcha.

Tillagd i version 3.11.

(?P<name>...)

Liknar vanliga parenteser, men den delsträng som matchas av gruppen är tillgänglig via det symboliska gruppnamnet namn. Gruppnamn måste vara giltiga Python-identifierare och i bytes-mönster kan de endast innehålla byte i ASCII-intervallet. Varje gruppnamn får bara definieras en gång inom ett reguljärt uttryck. En symbolisk grupp är också en numrerad grupp, precis som om gruppen inte hade något namn.

Namngivna grupper kan refereras till i tre sammanhang. Om mönstret är (?P<quote>['"]).*?(?P=quote) (d.v.s. matchning av en sträng som citeras med antingen enkla eller dubbla citattecken):

Sammanhang med hänvisning till gruppen ”offert”

Sätt att hänvisa till den

i samma mönster själv

  • (?P=quote) (som visas)

  • \1

vid bearbetning av matchningsobjekt m

  • m.group('quote')

  • m.end('quote') (etc.)

i en sträng som skickas till repl-argumentet i re.sub()

  • <quote>

  • <1>

  • \1

Ändrad i version 3.12: I bytes-mönster kan gruppen name bara innehålla byte i ASCII-intervallet (b'\x00'-b'\x7f').

(?P=namn)

En återreferens till en namngiven grupp; den matchar den text som matchades av den tidigare gruppen med namnet namn.

(?#...)

En kommentar; innehållet i parentesen ignoreras helt enkelt.

(?=...)

Matchar om ... matchar nästa, men inte förbrukar någon del av strängen. Detta kallas för ett lookahead-assertion. Till exempel kommer Isaac (?=Asimov) att matcha 'Isaac' endast om det följs av 'Asimov'.

(?!...)

Matchar om ... inte matchar nästa. Detta är ett negativt lookahead-antagande. Till exempel kommer Isaac (?!Asimov) att matcha 'Isaac' endast om det inte följs av 'Asimov'.

(?<=...)

Matchar om den aktuella positionen i strängen föregås av en matchning för ... som slutar vid den aktuella positionen. Detta kallas ett positivt lookbehind-antagande. (?<=abc)def kommer att hitta en matchning i 'abcdef', eftersom lookbehind kommer att backa 3 tecken och kontrollera om det ingående mönstret matchar. Det ingående mönstret får bara matcha strängar av en viss bestämd längd, vilket innebär att abc eller a|b är tillåtna, men inte a* och a{3,4}. Observera att mönster som börjar med positiva lookbehind-assertions inte kommer att matcha i början av den sträng som söks; du kommer troligen att vilja använda funktionen search() snarare än funktionen match():

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

I det här exemplet söker du efter ett ord efter ett bindestreck:

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

Ändrad i version 3.5: Stöd för gruppreferenser med fast längd har lagts till.

(?<!...)

Träffar om den aktuella positionen i strängen inte föregås av en träff för .... Detta kallas ett negativt lookbehind-antagande. I likhet med positiva lookbehind-assertions måste det ingående mönstret endast matcha strängar av en viss bestämd längd. Mönster som börjar med negativa lookbehind-assertions kan matcha i början av den sträng som söks.

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

Försöker matcha med yes-pattern om gruppen med angivet id eller namn finns, och med no-pattern om den inte gör det. no-pattern är valfritt och kan utelämnas. Till exempel är (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) ett dåligt mönster för e-postmatchning, som kommer att matcha med '<user@host.com>' såväl som 'user@host.com', men inte med '<user@host.com' eller 'user@host.com>'.

Ändrad i version 3.12: Grupp id kan endast innehålla ASCII-siffror. I bytes-mönster kan grupp name endast innehålla bytes i ASCII-intervallet (b'\x00'-b'\x7f').

De speciella sekvenserna består av '\' och ett tecken från listan nedan. Om det vanliga tecknet inte är en ASCII-siffra eller en ASCII-bokstav, kommer den resulterande RE att matcha det andra tecknet. Till exempel matchar \$ tecknet '$'.

”Nummer

Matchar innehållet i gruppen med samma nummer. Grupperna är numrerade från 1. Till exempel matchar (.+) \1 'the the' eller '55 55', men inte 'thethe' (notera mellanslaget efter gruppen). Denna speciella sekvens kan endast användas för att matcha en av de första 99 grupperna. Om den första siffran i number är 0, eller number är 3 oktalsiffror långt, tolkas det inte som en gruppmatchning, utan som tecknet med oktalvärdet number. Inom '[' och ']' i en teckenklass behandlas alla numeriska eskapader som tecken.

\A

Matchar endast i början av strängen.

\b

Matchar den tomma strängen, men bara i början eller slutet av ett ord. Ett ord definieras som en sekvens av ordtecken. Observera att ”b” formellt definieras som gränsen mellan ett ”w”- och ett ”w”-tecken (eller vice versa), eller mellan ”w” och början eller slutet av strängen. Detta innebär att r'\bat\b' matchar 'at', 'at.', '(at)' och 'as at ay' men inte 'attempt' eller 'atlas'.

Standardordtecknen i Unicode (str)-mönster är Unicode-alfanumeriska tecken och understreck, men detta kan ändras med hjälp av flaggan ASCII. Ordgränser bestäms av den aktuella språkdräkten om flaggan LOCALE används.

Anteckning

Inom ett teckenintervall representerar b backspace-tecknet, för kompatibilitet med Pythons stränglitteraler.

\B

Matchar den tomma strängen, men bara när den inte står i början eller slutet av ett ord. Detta innebär att r'at\B' matchar 'athens', 'atom', 'attorney', men inte 'at', 'at.', eller 'at!'. B är motsatsen till b, så ordtecken i Unicode (str)-mönster är Unicodes alfanumeriska tecken eller understreck, även om detta kan ändras med hjälp av ASCII-flaggan. Ordgränser bestäms av den aktuella språkdräkten om flaggan LOCALE används.

Ändrad i version 3.14: B matchar nu tom indatasträng.

\d
För Unicode (str)-mönster:

Matchar alla Unicodes decimalsiffror (dvs. alla tecken i Unicodes teckenkategori [Nd]). Detta inkluderar [0-9] och även många andra siffertecken.

Matchar [0-9] om flaggan ASCII används.

För 8-bitars (bytes) mönster:

Matchar alla decimala siffror i ASCII-teckenuppsättningen; detta motsvarar [0-9].

\D

Matchar alla tecken som inte är en decimalsiffra. Detta är motsatsen till d.

Matchar [^0-9] om flaggan ASCII används.

\s
För Unicode (str)-mönster:

Matchar Unicode-tecken för blanksteg (enligt definitionen i str.isspace()). Detta inkluderar [ \t\n\r\f\v], och även många andra tecken, till exempel de icke-brytande mellanslag som krävs enligt typografiska regler i många språk.

Matchar [ \t\n\r\f\v] om flaggan ASCII används.

För 8-bitars (bytes) mönster:

Matchar tecken som betraktas som blanksteg i ASCII-teckensatsen; detta motsvarar [ \t\n\r\f\v].

\S

Matchar alla tecken som inte är blankstegstecken. Detta är motsatsen till ”s”.

Matchar [^ \t\n\r\f\v] om flaggan ASCII används.

\w
För Unicode (str)-mönster:

Matchar Unicode-ordtecken; detta inkluderar alla alfanumeriska Unicode-tecken (enligt definitionen i str.isalnum()), samt understreck (_).

Matchar [a-zA-Z0-9_] om flaggan ASCII används.

För 8-bitars (bytes) mönster:

Matchar tecken som anses vara alfanumeriska i ASCII-teckenuppsättningen; detta motsvarar [a-zA-Z0-9_]. Om flaggan LOCALE används, matchas tecken som anses vara alfanumeriska i den aktuella språkdräkten och understreck.

\W

Matchar alla tecken som inte är ordtecken. Detta är motsatsen till \w. Som standard matchas icke-underscore (_) tecken för vilka str.isalnum() returnerar False.

Matchar [^a-zA-Z0-9_] om flaggan ASCII används.

Om flaggan LOCALE används, matchar den tecken som varken är alfanumeriska i den aktuella språkdräkten eller underscore.

\z

Matchar endast i slutet av strängen.

Tillagd i version 3.14.

\Z

Samma som z. För kompatibilitet med gamla Python-versioner.

De flesta av de escape-sekvenser som stöds av Pythons stränglitteraler accepteras också av parsern för reguljära uttryck:

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

(Observera att b används för att representera ordgränser och betyder ”backspace” endast inom teckenklasser)

escape-sekvenserna '\u', '\U' och '\N' känns bara igen i Unicode-mönster (str). I bytesmönster är de fel. Okända escapes av ASCII-bokstäver reserveras för framtida användning och behandlas som fel.

Oktala escapes ingår i en begränsad form. Om den första siffran är en 0, eller om det finns tre oktalsiffror, betraktas det som en oktal escape. Annars är det en gruppreferens. När det gäller stränglitteraler är oktala escapes alltid högst tre siffror långa.

Ändrad i version 3.3: Escape-sekvenserna '\u' och '\U' har lagts till.

Ändrad i version 3.6: Okända escapes som består av '\' och en ASCII-bokstav är nu fel.

Ändrad i version 3.8: Escape-sekvensen '\N{name}' har lagts till. Precis som i stränglitteraler expanderar den till det namngivna Unicode-tecknet (t.ex. '\N{EM DASH}').

Modulens innehåll

Modulen definierar flera funktioner, konstanter och ett undantag. Vissa av funktionerna är förenklade versioner av de fullständiga metoderna för kompilerade reguljära uttryck. De flesta icke-triviala applikationer använder alltid den kompilerade formen.

Flaggor

Ändrad i version 3.6: Flaggkonstanter är nu instanser av RegexFlag, som är en underklass av enum.IntFlag.

class re.RegexFlag

En enum.IntFlag-klass som innehåller de regex-alternativ som anges nedan.

Tillagd i version 3.11: - added to __all__

re.A
re.ASCII

Gör så att w, W, b, B, d, D, s och S endast utför ASCII-matchning istället för fullständig Unicode-matchning. Detta är endast meningsfullt för Unicode-mönster (str) och ignoreras för bytes-mönster.

Motsvarar inline-flaggan (?a).

Anteckning

Flaggan U finns fortfarande kvar för bakåtkompatibilitet, men är överflödig i Python 3 eftersom matchningar är Unicode som standard för str-mönster och Unicode-matchning inte är tillåten för bytesmönster. Flaggan UNICODE och inline-flaggan (?u) är på samma sätt överflödiga.

re.DEBUG

Visa felsökningsinformation om kompilerade uttryck.

Ingen motsvarande inline-flagga.

re.I
re.IGNORECASE

Utför matchning utan hänsyn till skiftlägesskillnader; uttryck som [A-Z] matchar även små bokstäver. Fullständig Unicode-matchning (t.ex. Ü som matchar ü) fungerar också om inte flaggan ASCII används för att inaktivera icke-ASCII-matchningar. Den aktuella språkdräkten ändrar inte effekten av denna flagga om inte flaggan LOCALE också används.

Motsvarar inline-flaggan (?i).

Observera att när Unicode-mönstren [a-z] eller [A-Z] används i kombination med flaggan IGNORECASE, matchar de de 52 ASCII-bokstäverna och 4 ytterligare icke-ASCII-bokstäver: ’İ’ (U+0130, latinsk versal I med punkt ovanför), ’ı’ (U+0131, latinsk gemen i utan punkt), ’ſ’ (U+017F, latinsk gemen lång s) och ’K’ (U+212A, Kelvin-tecken). Om flaggan ASCII används matchas endast bokstäverna ’a’ till ’z’ och ’A’ till ’Z’.

re.L
re.LOCALE

Gör w, W, b, B och skiftlägesokänslig matchning beroende av aktuell lokal. Denna flagga kan endast användas med bytesmönster.

Motsvarar inline-flaggan (?L).

Varning

Denna flagga avrådes; överväg Unicode-matchning istället. Lokalmekanismen är mycket opålitlig eftersom den bara hanterar en ”kultur” åt gången och bara fungerar med 8-bitars lokalspråk. Unicode-matchning är aktiverad som standard för Unicode (str)-mönster och kan hantera olika lokala språk och språk.

Ändrad i version 3.6: LOCALE kan endast användas med bytesmönster och är inte kompatibel med ASCII.

Ändrad i version 3.7: Kompilerade objekt för reguljära uttryck med LOCALE-flaggan är inte längre beroende av locale vid kompileringstillfället. Endast locale vid matchningstillfället påverkar resultatet av matchningen.

re.M
re.MULTILINE

När det anges matchar mönsterstecknet '^' i början av strängen och i början av varje rad (omedelbart efter varje ny rad); och mönsterstecknet '$' matchar i slutet av strängen och i slutet av varje rad (omedelbart före varje ny rad). Som standard matchar '^' endast i början av strängen och '$' endast i slutet av strängen och omedelbart före den nya raden (om någon) i slutet av strängen.

Motsvarar inline-flaggan (?m).

re.NOFLAG

Indikerar att ingen flagga tillämpas, värdet är 0. Denna flagga kan användas som ett standardvärde för ett funktionsnyckelordsargument eller som ett basvärde som villkorligt OR:as med andra flaggor. Exempel på användning som standardvärde:

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)

Tillagd i version 3.11.

re.S
re.DOTALL

Låt specialtecknet '.' matcha vilket tecken som helst, inklusive en ny rad; utan denna flagga kommer '.' att matcha allt utom en ny rad.

Motsvarar den inline-flaggan (?s).

re.U
re.UNICODE

I Python 3 matchas Unicode-tecken som standard för str-mönster. Denna flagga är därför överflödig med ingen effekt och behålls endast för bakåtkompatibilitet.

Se ASCII för att begränsa matchningen till ASCII-tecken istället.

re.X
re.VERBOSE

Med den här flaggan kan du skriva reguljära uttryck som ser snyggare ut och är mer läsbara genom att du visuellt kan separera logiska delar av mönstret och lägga till kommentarer. Whitespace inom mönstret ignoreras, utom när det är i en teckenklass, eller när det föregås av ett oavkortat backslash, eller inom tokens som *?, (?: eller (?P<...>. Till exempel är (? : och * ? inte tillåtna. När en rad innehåller en # som inte ingår i en teckenklass och som inte föregås av en obegränsad backslash, ignoreras alla tecken från den längst till vänster liggande sådana # till slutet av raden.

Detta innebär att de två följande objekten för reguljära uttryck som matchar ett decimaltal är funktionellt lika:

a = re.compile(r"""\d + # den integrerade delen
                   \.    # decimalpunkten
                   \d * # några fraktionssiffror""", re.X)
b = re.compile(r"\d+\.\d*")

Motsvarar inline-flaggan (?x).

Funktioner

re.compile(pattern, flags=0)

Kompilera ett mönster för reguljära uttryck till ett regular expression object, som kan användas för matchning med hjälp av dess match(), search() och andra metoder, som beskrivs nedan.

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Sekvensen

prog = re.compile(mönster)
resultat = prog.match(sträng)

är likvärdig med

resultat = re.match(mönster, sträng)

men att använda re.compile() och spara det resulterande objektet för reguljära uttryck för återanvändning är effektivare när uttrycket kommer att användas flera gånger i ett och samma program.

Anteckning

De kompilerade versionerna av de senaste mönstren som skickas till re.compile() och matchningsfunktionerna på modulnivå cachas, så program som bara använder ett fåtal reguljära uttryck åt gången behöver inte oroa sig för att kompilera reguljära uttryck.

re.search(pattern, string, flags=0)

Skanna igenom sträng och leta efter den första platsen där det reguljära uttrycket mönster ger en träff, och returnera en motsvarande Match. Returnerar None om ingen position i strängen matchar mönstret; observera att detta skiljer sig från att hitta en noll-längdsmatchning någonstans i strängen.

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

re.match(pattern, string, flags=0)

Om noll eller fler tecken i början av sträng matchar det reguljära uttrycket mönster, returneras en motsvarande Match. Returnerar None om strängen inte matchar mönstret; notera att detta skiljer sig från en noll-längds matchning.

Observera att även i MULTILINE-läget kommer re.match() bara att matcha i början av strängen och inte i början av varje rad.

Om du vill hitta en träff var som helst i sträng, använd search() istället (se även sök() vs. match()).

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

re.fullmatch(pattern, string, flags=0)

Om hela strängen matchar det reguljära uttrycket mönstret, returneras en motsvarande Match. Returnerar None om strängen inte matchar mönstret; notera att detta skiljer sig från en matchning med noll längd.

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Tillagd i version 3.4.

re.split(pattern, string, maxsplit=0, flags=0)

Dela upp sträng efter förekomsterna av mönster. Om fångande parenteser används i mönster returneras även texten för alla grupper i mönstret som en del av den resulterande listan. Om maxsplit inte är noll, sker högst maxsplit uppdelningar och resten av strängen returneras som det sista elementet i listan.

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', maxsplit=1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

Om det finns fångstgrupper i separatorn och den matchar i början av strängen, kommer resultatet att börja med en tom sträng. Detsamma gäller för slutet av strängen:

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

På så sätt hittas separatorkomponenterna alltid på samma relativa index i resultatlistan.

Intilliggande tomma matchningar är inte möjliga, men en tom matchning kan inträffa omedelbart efter en icke-tom matchning.

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Ändrad i version 3.1: Lagt till det valfria flaggargumentet.

Ändrad i version 3.7: Stöd för uppdelning av ett mönster som kan matcha en tom sträng har lagts till.

Föråldrad sedan version 3.13: Att skicka maxsplit och flags som positionella argument är föråldrat. I framtida Python-versioner kommer de att vara keyword-only parameters.

re.findall(pattern, string, flags=0)

Returnerar alla icke-överlappande matchningar av mönster i sträng, som en lista med strängar eller tupler. sträng skannas från vänster till höger och matchningarna returneras i den ordning de hittas. Tomma matchningar inkluderas i resultatet.

Resultatet beror på antalet fångstgrupper i mönstret. Om det inte finns några grupper returneras en lista med strängar som matchar hela mönstret. Om det finns exakt en grupp returneras en lista med strängar som matchar den gruppen. Om det finns flera grupper returneras en lista med tupler av strängar som matchar grupperna. Grupper som inte fångas upp påverkar inte resultatets form.

>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
[('width', '20'), ('height', '10')]

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Ändrad i version 3.7: Matcher som inte är tomma kan nu starta precis efter en tidigare tom match.

re.finditer(pattern, string, flags=0)

Returnerar en iterator som ger Match-objekt över alla icke-överlappande matchningar för RE mönster i sträng. strängen skannas från vänster till höger och matchningarna returneras i den ordning de hittas. Tomma matchningar inkluderas i resultatet.

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Ändrad i version 3.7: Matcher som inte är tomma kan nu starta precis efter en tidigare tom match.

re.sub(pattern, repl, string, count=0, flags=0)

Returnerar strängen som erhålls genom att ersätta de längst till vänster liggande icke överlappande förekomsterna av mönster i sträng med ersättningen repl. Om mönstret inte hittas returneras sträng oförändrad. repl kan vara en sträng eller en funktion; om det är en sträng behandlas alla backslash-escapes i den. Det innebär att \n konverteras till ett enda ny rad-tecken, r konverteras till en vagnsretur och så vidare. Okända escapes av ASCII-bokstäver reserveras för framtida användning och behandlas som fel. Andra okända escapetecken som & lämnas därhän. Bakreferenser, t.ex. \6, ersätts med den delsträng som matchas av grupp 6 i mönstret. Till exempel:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

Om repl är en funktion anropas den för varje icke-överlappande förekomst av pattern. Funktionen tar ett enda Match-argument och returnerar ersättningssträngen. Till exempel:

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
...
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'

Mönstret kan vara en sträng eller en Pattern.

Det valfria argumentet count är det maximala antalet mönsterförekomster som ska ersättas; count måste vara ett icke-negativt heltal. Om det utelämnas eller är noll kommer alla förekomster att ersättas.

Intilliggande tomma matchningar är inte möjliga, men en tom matchning kan inträffa omedelbart efter en icke-tom matchning. Därför returnerar sub('x*', '-', 'abxd') '-a-b--d-' i stället för '-a-b-d-'.

I repl-argument av strängtyp, utöver de teckenundantag och bakåtreferenser som beskrivs ovan, kommer g<name> att använda den delsträng som matchas av gruppen med namnet namn, enligt definitionen i syntaxen (?P<name>...). \g<number> använder motsvarande gruppnummer; g<2> är därför likvärdigt med 2, men är inte tvetydigt i en ersättning som g<2>0. 20 skulle tolkas som en referens till grupp 20, inte en referens till grupp 2 följt av det bokstavliga tecknet '0'. Bakreferensen \g<0> ersätter hela den delsträng som matchas av RE.

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

Ändrad i version 3.1: Lagt till det valfria flaggargumentet.

Ändrad i version 3.5: Omatchade grupper ersätts med en tom sträng.

Ändrad i version 3.6: Okända escapes i mönster som består av '\' och en ASCII-bokstav är nu fel.

Ändrad i version 3.7: Okända escapes i repl som består av '\' och en ASCII-bokstav är nu fel. En tom matchning kan inträffa omedelbart efter en icke-tom matchning.

Ändrad i version 3.12: Grupp id kan bara innehålla ASCII-siffror. I bytes ersättningssträngar kan grupp name endast innehålla bytes i ASCII-intervallet (b'\x00'-b'\x7f').

Föråldrad sedan version 3.13: Att skicka count och flags som positionella argument är föråldrat. I framtida Python-versioner kommer de att vara keyword-only parameters.

re.subn(pattern, repl, string, count=0, flags=0)

Utför samma operation som sub(), men returnerar en tupel (new_string, number_of_subs_made).

Uttryckets beteende kan ändras genom att ange ett flags-värde. Värdena kan vara vilken som helst av variablerna flags, kombinerade med bitvis OR (operatorn |).

re.escape(pattern)

Undvik specialtecken i mönster. Detta är användbart om du vill matcha en godtycklig bokstavlig sträng som kan innehålla metatecken för reguljära uttryck. Till exempel:

>>> print(re.escape('https://www.python.org'))
https://www\.python\.org

>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\ -\.\^_`\|\~:]+

>>> operators = ['+', '-', '*', '/', '**']
>>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
/|\ -|\+|\*\*|\*

Denna funktion får inte användas för ersättningssträngen i sub() och subn(), endast backslashes ska escapas. Till exempel:

>>> digits_re = r'\d+'
>>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
>>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
/usr/sbin/sendmail - \d+ errors, \d+ warnings

Ändrad i version 3.3: Tecknet '_' är inte längre escapat.

Ändrad i version 3.7: Endast tecken som kan ha en speciell betydelse i ett reguljärt uttryck escapas. Därför undviks inte längre '!', '"', '%', "'', ',', '/', ':', ';', '<', '=', '>', '@' och "`".

re.purge()

Rensa cacheminnet för reguljära uttryck.

Undantag

exception re.PatternError(msg, pattern=None, pos=None)

Undantag som uppstår när en sträng som skickas till en av funktionerna här inte är ett giltigt reguljärt uttryck (det kan t.ex. innehålla parenteser som inte matchar) eller när något annat fel uppstår under kompilering eller matchning. Det är aldrig ett fel om en sträng inte innehåller någon matchning för ett mönster. Instansen PatternError har följande ytterligare attribut:

msg

Det oformaterade felmeddelandet.

pattern

Det reguljära uttrycksmönstret.

pos

Indexet i mönster där kompileringen misslyckades (kan vara None).

lineno

Den rad som motsvarar pos (kan vara None).

colno

Den kolumn som motsvarar pos (kan vara None).

Ändrad i version 3.5: Lagt till ytterligare attribut.

Ändrad i version 3.13: PatternError hette ursprungligen error; det senare behålls som ett alias för bakåtkompatibilitet.

Objekt för reguljära uttryck

class re.Pattern

Kompilerat objekt för reguljära uttryck som returneras av re.compile().

Ändrad i version 3.9: re.Pattern stöder [] för att ange ett Unicode- (str) eller bytesmönster. Se Generisk aliastyp.

Pattern.search(string[, pos[, endpos]])

Skanna igenom sträng och leta efter den första platsen där detta reguljära uttryck ger en träff, och returnera en motsvarande Match. Returnerar None om ingen position i strängen matchar mönstret; observera att detta skiljer sig från att hitta en noll-längdsmatchning någonstans i strängen.

Den valfria andra parametern pos anger ett index i strängen där sökningen ska börja; standardvärdet är 0. Detta är inte helt likvärdigt med att skära upp strängen; mönsterstecknet '^' matchar i strängens verkliga början och vid positioner strax efter en ny rad, men inte nödvändigtvis vid det index där sökningen ska börja.

Den valfria parametern endpos begränsar hur långt strängen kommer att sökas; det kommer att vara som om strängen är endpos tecken lång, så endast tecknen från pos till endpos - 1 kommer att sökas efter en matchning. Om endpos är mindre än pos kommer ingen matchning att hittas; annars, om rx är ett kompilerat objekt för reguljära uttryck, är rx.search(string, 0, 50) likvärdigt med rx.search(string[:50], 0).

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"
Pattern.match(string[, pos[, endpos]])

Om noll eller fler tecken i början av sträng matchar detta reguljära uttryck, returneras en motsvarande Match. Returnerar None om strängen inte matchar mönstret; observera att detta skiljer sig från en noll-längdsmatchning.

De valfria parametrarna pos och endpos har samma betydelse som för metoden search().

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>

Om du vill hitta en matchning var som helst i sträng, använd search() istället (se även sök() vs. match()).

Pattern.fullmatch(string[, pos[, endpos]])

Om hela strängen matchar detta reguljära uttryck, returneras en motsvarande Match. Returnerar None om strängen inte matchar mönstret; notera att detta skiljer sig från en noll-längdsmatchning.

De valfria parametrarna pos och endpos har samma betydelse som för metoden search().

>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.fullmatch("ogre")     # No match as not the full string matches.
>>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>

Tillagd i version 3.4.

Pattern.split(string, maxsplit=0)

Identisk med funktionen split(), men med det kompilerade mönstret.

Pattern.findall(string[, pos[, endpos]])

Liknar funktionen findall(), använder det kompilerade mönstret, men accepterar också valfria parametrar pos och endpos som begränsar sökregionen som för search().

Pattern.finditer(string[, pos[, endpos]])

Liknar funktionen finditer(), använder det kompilerade mönstret, men accepterar också valfria parametrar pos och endpos som begränsar sökregionen som för search().

Pattern.sub(repl, string, count=0)

Identisk med funktionen sub(), men använder det kompilerade mönstret.

Pattern.subn(repl, string, count=0)

Identisk med funktionen subn(), men med det kompilerade mönstret.

Pattern.flags

Flaggorna för regex-matchning. Detta är en kombination av de flaggor som ges till compile(), eventuella (?...) inline-flaggor i mönstret och implicita flaggor som UNICODE om mönstret är en Unicode-sträng.

Pattern.groups

Antalet fångstgrupper i mönstret.

Pattern.groupindex

En ordbok som mappar alla symboliska gruppnamn som definieras av (?P<id>) till gruppnummer. Ordlistan är tom om inga symboliska grupper har använts i mönstret.

Pattern.pattern

Den mönstersträng från vilken mönsterobjektet sammanställdes.

Ändrad i version 3.7: Lagt till stöd för copy.copy() och copy.deepcopy(). Kompilerade objekt för reguljära uttryck betraktas som atomära.

Matchningsobjekt

Match-objekt har alltid det booleska värdet True. Eftersom match() och search() returnerar None när det inte finns någon matchning, kan du testa om det fanns en matchning med en enkel if-sats:

match = re.search(mönster, sträng)
om match:
    process(match)
class re.Match

Matchningsobjekt som returneras av framgångsrika ”matchningar” och ”sökningar”.

Ändrad i version 3.9: re.Match stöder [] för att ange en matchning med Unicode (str) eller bytes. Se Generisk aliastyp.

Match.expand(template)

Returnerar strängen som erhålls genom att göra backslash-substitution på mallsträngen template, vilket görs av metoden sub(). Escapes som \n konverteras till lämpliga tecken, och numeriska backreferenser (1, 2) och namngivna backreferenser (\g<1>, g<name>) ersätts av innehållet i motsvarande grupp. Bakreferensen \g<0> kommer att ersättas av hela matchningen.

Ändrad i version 3.5: Omatchade grupper ersätts med en tom sträng.

Match.group([group1, ...])

Returnerar en eller flera undergrupper av matchningen. Om det finns ett enda argument är resultatet en enda sträng; om det finns flera argument är resultatet en tupel med ett objekt per argument. Utan argument är group1 standardvärdet noll (hela matchningen returneras). Om ett groupN-argument är noll är motsvarande returvärde hela den matchande strängen; om det är i det inkluderande intervallet [1..99] är det den sträng som matchar motsvarande grupp inom parentes. Om ett gruppnummer är negativt eller större än det antal grupper som definieras i mönstret, uppstår ett IndexError undantag. Om en grupp ingår i en del av mönstret som inte matchade, är motsvarande resultat None. Om en grupp ingår i en del av mönstret som matchade flera gånger, returneras den sista matchningen.

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # The entire match
'Isaac Newton'
>>> m.group(1)       # The first parenthesized subgroup.
'Isaac'
>>> m.group(2)       # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2)    # Multiple arguments give us a tuple.
('Isaac', 'Newton')

Om det reguljära uttrycket använder syntaxen (?P<name>...) kan groupN-argumenten också vara strängar som identifierar grupper med deras gruppnamn. Om ett strängargument inte används som ett gruppnamn i mönstret, uppstår ett IndexError undantag.

Ett måttligt komplicerat exempel:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

Namngivna grupper kan också hänvisas till genom sitt index:

>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'

Om en grupp matchar flera gånger är det bara den sista matchningen som är tillgänglig:

>>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
>>> m.group(1)                        # Returns only the last match.
'c3'
Match.__getitem__(g)

Detta är identiskt med m.group(g). Detta gör det lättare att få tillgång till en enskild grupp från en matchning:

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0]       # The entire match
'Isaac Newton'
>>> m[1]       # The first parenthesized subgroup.
'Isaac'
>>> m[2]       # The second parenthesized subgroup.
'Newton'

Namngivna grupper stöds också:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Isaac Newton")
>>> m['first_name']
'Isaac'
>>> m['last_name']
'Newton'

Tillagd i version 3.6.

Match.groups(default=None)

Returnerar en tupel som innehåller alla undergrupper i matchningen, från 1 upp till hur många grupper som helst i mönstret. Argumentet default används för grupper som inte deltog i matchningen; standardvärdet är None.

Till exempel:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

Om vi gör decimaltecknet och allt efter det valfritt kan det hända att inte alla grupper deltar i matchningen. Dessa grupper kommer som standard att vara None om inte default-argumentet anges:

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Second group defaults to None.
('24', None)
>>> m.groups('0')   # Now, the second group defaults to '0'.
('24', '0')
Match.groupdict(default=None)

Returnerar en ordbok som innehåller alla namngivna undergrupper i matchningen, med undergruppsnamnet som nyckel. Argumentet default används för grupper som inte deltog i matchningen; standardvärdet är None. Till exempel:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
Match.start([group])
Match.end([group])

Returnerar indexen för början och slutet av den delsträng som matchas av group; group är som standard noll (vilket betyder hela den matchade delsträngen). Returnerar -1 om group finns men inte bidrog till matchningen. För ett matchningsobjekt m och en grupp g som bidrog till matchningen är den delsträng som matchas av gruppen g (motsvarande m.group(g))

m.string[m.start(g):m.slut(g)]

Observera att m.start(group) kommer att vara lika med m.end(group) om group matchade en nollsträng. Till exempel, efter m = re.search('b(c?)', 'cba'), är m.start(0) 1, m.end(0) är 2, m.start(1) och m.end(1) är båda 2, och m.start(2) ger upphov till ett IndexError undantag.

Ett exempel som tar bort remove_this från e-postadresser:

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
Match.span([group])

För en matchning m returneras 2-tupeln (m.start(group), m.end(group)). Observera att om grupp inte bidrog till matchen är detta (-1, -1). group är standardvärdet noll, hela matchningen.

Match.pos

Värdet på pos som skickades till metoden search() eller match() i ett regexobjekt. Detta är det index i strängen där RE-motorn började leta efter en matchning.

Match.endpos

Värdet på endpos som skickades till metoden search() eller match() i en regexobjekt. Detta är det index i strängen som RE-motorn inte kommer längre än så.

Match.lastindex

Heltalsindexet för den senast matchade fångstgruppen, eller None om ingen grupp matchades alls. Till exempel kommer uttrycken (a)b, ((a)(b)) och ((ab)) att ha lastindex == 1 om de tillämpas på strängen 'ab', medan uttrycket (a)(b) kommer att ha lastindex == 2 om det tillämpas på samma sträng.

Match.lastgroup

Namnet på den senast matchade fångstgruppen, eller None om gruppen inte hade något namn, eller om ingen grupp matchades alls.

Match.re

Den objekt för reguljära uttryck vars match() eller search() metod producerade denna matchningsinstans.

Match.string

Den sträng som skickas till match() eller search().

Ändrad i version 3.7: Lagt till stöd för copy.copy() och copy.deepcopy(). Matchningsobjekt betraktas som atomära.

Exempel på reguljära uttryck

Kontrollerar för ett par

I det här exemplet använder vi följande hjälpfunktion för att visa matchningsobjekt på ett lite mer elegant sätt:

def displaymatch(match):
    om match är None:
        returnera Ingen
    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

Anta att du skriver ett pokerprogram där en spelares hand representeras av en sträng med 5 tecken där varje tecken representerar ett kort, ”a” för ess, ”k” för kung, ”q” för dam, ”j” för knekt, ”t” för 10 och ”2” till ”9” representerar kortet med det värdet.

För att se om en given sträng är en giltig hand kan man göra följande:

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q"))  # Valid.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Invalid.
>>> displaymatch(valid.match("akt"))    # Invalid.
>>> displaymatch(valid.match("727ak"))  # Valid.
"<Match: '727ak', groups=()>"

Den sista handen, "727ak", innehöll ett par eller två kort med samma värde. För att matcha detta med ett reguljärt uttryck kan man använda backreferenser som t.ex:

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Pair of 7s.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # No pairs.
>>> displaymatch(pair.match("354aa"))     # Pair of aces.
"<Match: '354aa', groups=('a',)>"

För att ta reda på vilket kort paret består av kan man använda group()-metoden för match-objektet på följande sätt:

>>> pair = re.compile(r".*(.).*\1")
>>> pair.match("717ak").group(1)
'7'

# Error because re.match() returns None, which doesn't have a group() method:
>>> pair.match("718ak").group(1)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    re.match(r".*(.).*\1", "718ak").group(1)
AttributeError: 'NoneType' object has no attribute 'group'

>>> pair.match("354aa").group(1)
'a'

Simulering av scanf()

Python har för närvarande ingen motsvarighet till scanf(). Reguljära uttryck är i allmänhet mer kraftfulla, men också mer verbala, än scanf() formatsträngar. Tabellen nedan visar några mer eller mindre likvärdiga mappningar mellan scanf()-formattokens och reguljära uttryck.

scanf() Token

Reguljärt uttryck

%c

.

%5c

.{5}

%d

[-+]?\d+

%e, %E, %f, %g

[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?

%i

[-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+)

%o

[-+]?[0-7]+

%s

\S+

%u

\d+

%x, %X

[-+]?(0[xX])?[\dA-Fa-f]+

Så här extraherar du filnamn och siffror från en sträng som

/usr/sbin/sendmail - 0 fel, 4 varningar

skulle du använda ett scanf()-format som

%s - %d fel, %d varningar

Motsvarande reguljära uttryck skulle vara

(\S+) - (\d+) fel, (\d+) varningar

sök() vs. match()

Python erbjuder olika primitiva operationer baserade på reguljära uttryck:

  • re.match() söker efter en matchning endast i början av strängen

  • re.search() söker efter en träff var som helst i strängen (detta är vad Perl gör som standard)

  • re.fullmatch() kontrollerar att hela strängen är en matchning

Till exempel:

>>> re.match("c", "abcdef")    # No match
>>> re.search("c", "abcdef")   # Match
<re.Match object; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Match
<re.Match object; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") # No match

Reguljära uttryck som börjar med '^' kan användas med search() för att begränsa matchningen till början av strängen:

>>> re.match("c", "abcdef")    # No match
>>> re.search("^c", "abcdef")  # No match
>>> re.search("^a", "abcdef")  # Match
<re.Match object; span=(0, 1), match='a'>

Observera dock att i MULTILINE-läget matchar match() bara i början av strängen, medan search() med ett reguljärt uttryck som börjar med '^' matchar i början av varje rad:

>>> re.match("X", "A\nB\nX", re.MULTILINE)  # No match
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Match
<re.Match object; span=(4, 5), match='X'>

Skapa en telefonbok

split() delar upp en sträng i en lista som avgränsas av det passerade mönstret. Metoden är ovärderlig för att konvertera textdata till datastrukturer som lätt kan läsas och modifieras av Python, vilket visas i följande exempel som skapar en telefonbok.

Först, här är indata. Normalt kan den komma från en fil, här använder vi trippelciterad strängsyntax

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""

Posterna är åtskilda av en eller flera nya linjer. Nu omvandlar vi strängen till en lista där varje icke-tom rad har en egen post:

>>> entries = re.split("\n+", text)
>>> entries
['Ross McFluff: 834.345.1254 155 Elm Street',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']

Slutligen delar vi upp varje post i en lista med förnamn, efternamn, telefonnummer och adress. Vi använder parametern maxsplit i split() eftersom adressen innehåller mellanslag, vårt uppdelningsmönster:

>>> [re.split(":? ", entry, maxsplit=3) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

Mönstret :? matchar kolon efter efternamnet, så att det inte förekommer i resultatlistan. Med en maxsplit4 kan vi separera husnumret från gatunamnet:

>>> [re.split(":? ", entry, maxsplit=4) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

Text Munging

sub() ersätter varje förekomst av ett mönster med en sträng eller resultatet av en funktion. I det här exemplet används sub() tillsammans med en funktion för att ”mjuka upp” text, dvs. slumpa fram ordningen på alla tecken i varje ord i en mening utom det första och sista tecknet:

>>> def repl(m):
...     inner_word = list(m.group(2))
...     random.shuffle(inner_word)
...     return m.group(1) + "".join(inner_word) + m.group(3)
...
>>> text = "Professor Abdolmalek, please report your absences promptly."
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

Hitta alla adverb

findall() matchar alla förekomster av ett mönster, inte bara den första som search() gör. Om en skribent till exempel vill hitta alla adverb i en text, kan han använda findall() på följande sätt:

>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly\b", text)
['carefully', 'quickly']

Hitta alla adverb och deras positioner

Om man vill ha mer information om alla matchningar av ett mönster än den matchade texten, är finditer() användbar eftersom den tillhandahåller Match-objekt istället för strängar. Om vi fortsätter med det tidigare exemplet och en skribent vill hitta alla adverb och deras positioner i en text, skulle han använda finditer() på följande sätt:

>>> text = "He was carefully disguised but captured quickly by police."
>>> for m in re.finditer(r"\w+ly\b", text):
...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: carefully
40-47: quickly

Notation av råa strängar

Rå strängnotation (r"text") håller reguljära uttryck sunda. Utan den skulle varje backslash ('\') i ett reguljärt uttryck behöva föregås av en annan för att undkomma den. Till exempel är de två följande raderna med kod funktionellt identiska:

>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>

När man vill matcha en bokstavlig backslash måste den escapas i det reguljära uttrycket. Med rå strängnotation betyder detta r"\\". Utan rå strängnotation måste man använda "\\\\", vilket gör följande kodrader funktionellt identiska:

>>> re.match(r"\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>

Skriva en Tokenizer

En tokenizer eller scanner analyserar en sträng för att kategorisera grupper av tecken. Detta är ett användbart första steg i att skriva en kompilator eller tolk.

Textkategorierna specificeras med reguljära uttryck. Tekniken är att kombinera dessa till ett enda övergripande reguljärt uttryck och att loopa över successiva matchningar:

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('ASSIGN',   r':='),           # Assignment operator
        ('END',      r';'),            # Statement terminator
        ('ID',       r'[A-Za-z]+'),    # Identifiers
        ('OP',       r'[+\ -*/]'),      # Arithmetic operators
        ('NEWLINE',  r'\n'),           # Line endings
        ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
        ('MISMATCH', r'.'),            # Any other character
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

Tokenizer producerar följande utdata:

Token(type='IF', value='IF', rad=2, kolumn=4)
Token(type='ID', value='quantity', rad=2, kolumn=7)
Token(type='THEN', value='THEN', line=2, column=16)
Token(typ='ID', värde='total', rad=3, kolumn=8)
Token(type='ASSIGN', value=':=', line=3, column=14)
Token(typ='ID', värde='total', rad=3, kolumn=17)
Token(type='OP', value='+', line=3, column=23)
Token(typ='ID', värde='pris', rad=3, kolumn=25)
Token(typ="OP", värde="*", rad=3, kolumn=31)
Token(type='ID', value='quantity', rad=3, kolumn=33)
Token(type='END', value=';', line=3, column=41)
Token(type='ID', value='tax', rad=4, kolumn=8)
Token(type='ASSIGN', value=':=', line=4, column=12)
Token(typ='ID', värde='pris', rad=4, kolumn=15)
Token(type='OP', value='*', line=4, column=21)
Token(typ='NUMBER', värde=0,05, rad=4, kolumn=23)
Token(type='END', value=';', line=4, column=27)
Token(type='ENDIF', value='ENDIF', line=5, column=4)
Token(typ='END', värde=';', rad=5, kolumn=9)
[Frie09]

Friedl, Jeffrey. Mastering Regular Expressions. 3:e upplagan, O’Reilly Media, 2009. Den tredje upplagan av boken täcker inte längre Python alls, men den första upplagan täckte att skriva bra reguljära uttrycksmönster i stor detalj.