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 uttrycketfoo$
endast matchar ’foo’. Mer intressant är att en sökning efterfoo.$
i'foo1\nfoo2\n'
normalt matchar ’foo2’, men ’foo1’ iMULTILINE
-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å få 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 kommera*a
att matcha'aaaa'
eftersoma*
kommer att matcha alla 4'a'
s, men när den sista'a'
påträffas, spåras uttrycket tillbaka så atta*
i slutändan matchar 3'a'
s totalt, och den fjärde'a'
matchas av den sista'a'
. Men nära*+a
används för att matcha'aaaa'
kommera*+
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++
ochx?+
ä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 kommera{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å få 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 kommera{3,5}
att matcha 5'a'
-tecken, medana{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ökera{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, medana{3,5}aa
kommer att matcha meda{3,5}
som fångar 5, sedan 4'a'
-tecken genom backtracking och sedan matchas de sista 2'a'
-tecken av den sistaaa
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ån00
till59
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
ellern
, eller en teckenklass, t.ex.w
ellerS
(definieras nedan). Observera attb
representerar ett enskilt ”backspace”-tecken, inte en ordgräns utanför en uppsättning, och numeriska escapes som1
är alltid oktala escapes, inte gruppreferenser. Specialsekvenser som inte matchar ett enda tecken, t.ex.A
ochz
, ä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 kommerIsaac (?=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 kommerIsaac (?!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 attabc
ellera|b
är tillåtna, men intea*
ocha{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 funktionensearch()
snarare än funktionenmatch()
:>>> 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 medno-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 flagganLOCALE
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 tillb
, så ordtecken i Unicode (str)-mönster är Unicodes alfanumeriska tecken eller understreck, även om detta kan ändras med hjälp avASCII
-flaggan. Ordgränser bestäms av den aktuella språkdräkten om flagganLOCALE
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 flagganASCII
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 flagganASCII
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 flagganASCII
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 flagganASCII
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 flagganASCII
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 flagganLOCALE
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 vilkastr.isalnum()
returnerarFalse
.Matchar
[^a-zA-Z0-9_]
om flagganASCII
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
ochS
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)
.
- 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 flagganASCII
används för att inaktivera icke-ASCII-matchningar. Den aktuella språkdräkten ändrar inte effekten av denna flagga om inte flagganLOCALE
också används.Motsvarar inline-flaggan
(?i)
.Observera att när Unicode-mönstren
[a-z]
eller[A-Z]
används i kombination med flagganIGNORECASE
, 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 flagganASCII
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.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
. ReturnerarNone
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
. ReturnerarNone
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 kommerre.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
. ReturnerarNone
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 namnetnamn
, enligt definitionen i syntaxen(?P<name>...)
.\g<number>
använder motsvarande gruppnummer;g<2>
är därför likvärdigt med2
, men är inte tvetydigt i en ersättning somg<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()
ochsubn()
, 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 ursprungligenerror
; 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
. ReturnerarNone
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, ärrx.search(string, 0, 50)
likvärdigt medrx.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
. ReturnerarNone
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
. ReturnerarNone
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örsearch()
.
- 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örsearch()
.
- 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 somUNICODE
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 resultatNone
. 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 ettIndexError
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 (motsvarandem.group(g)
)m.string[m.start(g):m.slut(g)]
Observera att
m.start(group)
kommer att vara lika medm.end(group)
om group matchade en nollsträng. Till exempel, efterm = re.search('b(c?)', 'cba')
, ärm.start(0)
1,m.end(0)
är 2,m.start(1)
ochm.end(1)
är båda 2, ochm.start(2)
ger upphov till ettIndexError
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()
ellermatch()
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()
ellermatch()
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 halastindex == 1
om de tillämpas på strängen'ab'
, medan uttrycket(a)(b)
kommer att halastindex == 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()
ellersearch()
metod producerade denna matchningsinstans.
Ä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.
|
Reguljärt uttryck |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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ängenre.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 maxsplit
på 4
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)
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.