re – Reguliere expressie operaties¶

Reguliere expressie syntax¶

Een reguliere expressie (of RE) specificeert een set van strings die ermee overeenkomt; de functies in deze module laten je controleren of een bepaalde string overeenkomt met een gegeven reguliere expressie (of als een gegeven reguliere expressie overeenkomt met een bepaalde string, wat op hetzelfde neerkomt).

Reguliere uitdrukkingen kunnen worden samengevoegd om nieuwe reguliere uitdrukkingen te vormen; als A en B beide reguliere uitdrukkingen zijn, dan is AB ook een reguliere uitdrukking. In het algemeen, als een string p met A overeenkomt en een andere string q met B, dan zal de string pq met AB overeenkomen. Dit geldt tenzij A of B operaties met een lage precedentie bevatten; grensvoorwaarden tussen A en B; of genummerde groepsverwijzingen hebben. Complexe uitdrukkingen kunnen dus gemakkelijk worden geconstrueerd uit eenvoudiger primitieve uitdrukkingen zoals hier beschreven. Voor details over de theorie en implementatie van reguliere expressies, raadpleeg het Friedl boek, of bijna elk leerboek over compiler constructie.

Een korte uitleg van het formaat van reguliere expressies volgt nu. Voor meer informatie en een vriendelijker presentatie, raadpleeg de Regular Expression HOWTO.

Reguliere expressies kunnen zowel speciale als gewone tekens bevatten. De meeste gewone tekens, zoals 'A', 'a', of '0', zijn de eenvoudigste reguliere expressies; ze komen gewoon met zichzelf overeen. U kunt gewone tekens aan elkaar koppelen, zodat last overeenkomt met de tekenreeks 'last'. (In de rest van dit hoofdstuk schrijven we RE’s in this special style, meestal zonder aanhalingstekens, en de te matchen tekenreeksen 'in single quotes'.)

Sommige tekens, zoals '|' of '(', zijn speciaal. Speciale tekens staan ofwel voor klassen van gewone tekens, of hebben invloed op de manier waarop de reguliere expressies eromheen worden geïnterpreteerd.

Herhalingskwalifiers (*, +, ?, {m,n}, enz.) kunnen niet direct genest worden. Dit voorkomt ambiguïteit met de niet-greedy modifier suffix?, en met andere modifiers in andere implementaties. Om een tweede herhaling toe te passen op een binnen-herhaling, kunnen haakjes gebruikt worden. Bijvoorbeeld, de uitdrukking (?:a{6})* komt overeen met elk veelvoud van zes 'a' tekens.

De speciale tekens zijn:

.

(Punt.) In de standaardmodus komt dit overeen met elk teken behalve een nieuwe regel. Als de vlag DOTALL is gespecificeerd, komt dit overeen met elk teken, inclusief een newline.

^

(Caret.) Komt overeen met het begin van de string, en in MULTILINE mode ook met onmiddellijk na elke newline.

$

Komt overeen met het einde van de string of net voor de newline aan het einde van de string, en in MULTILINE mode ook met onmiddellijk voor een newline. foo komt overeen met zowel ‘foo’ als ‘foobar’, terwijl de reguliere uitdrukking foo$ alleen overeenkomt met ‘foo’. Interessanter is dat zoeken naar foo.$ in 'foo1\nfoo2\n' normaal overeenkomt met ‘foo2’, maar in MULTILINE-modus met ‘foo1’; zoeken naar een enkele $ in 'foo\n' zal twee (lege) overeenkomsten opleveren: een net voor de newline, en een aan het eind van de string.

*

Zorgt ervoor dat de resulterende RE overeenkomt met 0 of meer herhalingen van de voorgaande RE, zoveel herhalingen als mogelijk zijn. ab* komt overeen met ‘a’, ‘ab’, of ‘a’ gevolgd door een willekeurig aantal ‘b’s.

+

De resulterende RE komt overeen met 1 of meer herhalingen van de vorige RE. ab+ komt overeen met ‘a’ gevolgd door een willekeurig aantal ‘b’s; alleen ‘a’ komt niet overeen.

?

De resulterende RE komt overeen met 0 of 1 herhaling van de voorafgaande RE.ab? komt overeen met ‘a’ of ‘ab’.

*?,+?,??

De kwalificeerders '*', '+', en '?' zijn allemaal gulzig; ze komen overeen met zoveel mogelijk tekst als mogelijk. Soms is dit gedrag niet gewenst; als de RE<.*> gematcht wordt met '<a> b <c>', zal het met de hele string matchen, en niet enkel met '<a>'. Door ? na de qualifier toe te voegen, wordt de match op een niet-vette of minimale manier uitgevoerd; zo weinig mogelijk karakters zullen gematcht worden. Het gebruik van de RE <.*?> zal enkel overeenstemmen met '<a>'.

{m}

Specifieert dat exact m kopieën van de vorige RE moeten overeenstemmen; weinige karakters veroorzaken dat de volledige RE niet overeenstemt. a{6} zal bijvoorbeeld precies zes 'a'-tekens matchen, maar niet vijf.

{m,n}

De resulterende RE moet overeenkomen met m tot n herhalingen van de vorige RE, waarbij wordt geprobeerd zoveel mogelijk herhalingen te matchen. Bijvoorbeeld, a{3,5} zal overeenkomen met 3 tot 5 'a' tekens. Het weglaten van m geeft een ondergrens van nul aan, en het weglaten van n geeft een oneindige bovengrens aan. Als voorbeeld, a{4,}b komt overeen met 'aaaab' of duizend 'a' tekens gevolgd door een 'b', maar niet met 'aaab'. De komma mag niet worden weggelaten, anders zou de codeerder worden verward met de eerder beschreven vorm.

{m,n}?

De resulterende RE komt overeen met m tot n herhalingen van de voorgaande RE, waarbij wordt geprobeerd zo weinig mogelijk herhalingen te evenaren. Dit is dan de on-greedy versie van de vorige qualifier. Voor de tekenreeks van 6 tekens 'aaaaaa' bijvoorbeeld, komt a{3,5} overeen met 5 'a' tekens, terwijl a{3,5}? slechts met 3 tekens overeenkomt.

\

Hetzij ontsnapt aan speciale tekens (zodat u tekens als'*', '?', enzovoort kunt gebruiken), hetzij geeft het een speciale reeks aan; speciale reeksen worden hieronder besproken.

Als u geen ruwe string gebruikt om het patroon uit te drukken, onthoud dan dat Python ook de backslash gebruikt als een escape-sequentie in string-literals; als de escapesequentie niet wordt herkend door Python’s parser, worden de backslash en het daaropvolgende teken opgenomen in de resulterende string. Maar als Python de resulterende reeks wel zou herkennen, moet de backslash twee keer herhaald worden. Dit is ingewikkeld en moeilijk te begrijpen, dus het is sterk aanbevolen dat u strings gebruikt voor alle expressies, behalve de eenvoudigste.

Gebruikt om een reeks tekens aan te geven. In een set:

• Tekens kunnen afzonderlijk worden vermeld, bijv. komt overeen met 'a','m', of 'k'.

• Reksen tekens kunnen worden aangegeven door twee tekens op te geven en deze te scheiden door een '-', bijvoorbeeld komt overeen met elke ASCII-letter met kleine letters, komt overeen met alle getallen van twee cijfers van 00 tot 59, en komt overeen met elk hexadecimaal cijfer. Als - is ge-escaped (bijv. ) of als het als eerste of laatste teken is geplaatst (bijv. of ), zal het overeenkomen met een letterlijke '-'.

• Speciale tekens verliezen hun speciale betekenis binnen sets. komt bijvoorbeeld overeen met de letterlijke tekens '(', '+','*' of ')'.

• Tekenklassen zoals \w of \S (hieronder gedefinieerd) worden ook geaccepteerd binnen een set, hoewel de tekens waarmee ze overeenkomen afhangen van de vraag of de modusASCII of LOCALE van kracht is.

• Tekens die niet binnen een reeks vallen, kunnen worden gevonden door de reeks aan te vullen. Als het eerste teken van de reeks '^' is, zullen alle tekens die niet in de reeks voorkomen, worden gevonden. Bijvoorbeeld, komt overeen met elk teken behalve '5', en komt overeen met elk teken behalve'^'. ^ heeft geen speciale betekenis als het niet het eerste teken in de reeks is.

• Om een letterlijke ']' binnen een reeks te laten overeenkomen, laat u deze voorafgaan door een backslash of plaatst u deze aan het begin van de reeks. Zo komen bijvoorbeeld {}] en() beide overeen met een haakje.

• Het is mogelijk dat in de toekomst geneste sets en setbewerkingen zoals in Unicode TechnicalStandard #18 worden toegevoegd. Dit zou de syntaxis veranderen, dus om deze verandering te vergemakkelijken zal er voorlopig een FutureWarning worden toegevoegd in dubbelzinnige gevallen, inclusief sets die beginnen met een letterlijke '.

  (...)

  Vergelijkt elke reguliere expressie die zich binnen de haakjes bevindt, en geeft het begin en einde van een groep aan; de inhoud van een groep kan worden opgehaald nadat een overeenkomst is uitgevoerd, en kan later in de string worden gematcht met de \numberspeciale sequentie, die hieronder wordt beschreven. Om overeen te komen met de lettertekens '(' of ')', gebruikt u \( of \), of u sluit ze in met een tekenklasse: , .

  (?...)

  Dit is een uitbreidingsnotatie (een '?' na een '(' is verder niet zinvol). Het eerste teken na de '?' bepaalt wat de betekenis en verdere syntaxis van de constructie is. Extensies maken gewoonlijk geen nieuwe groep aan; (?P<name>...) is de enige uitzondering op deze regel. Hieronder volgen de momenteel ondersteunde extensies.

  (?aiLmsux)

  (Een of meer letters uit de reeks 'a', 'i', 'L', 'm','s', 'u', 'x'.) De groep komt overeen met de lege string; de letters stellen de overeenkomstige vlaggen in: re.A (ASCII-only matching),re.I (hoofdletters negeren), re.L (locale afhankelijk),re.M (multi-line), re.S (punt komt overeen met alles),re.U (Unicode matching), en re.X (verbose), voor de gehele reguliere expressie. (De vlaggen worden beschreven in Module Inhoud.)Dit is nuttig indien u de vlaggen wenst op te nemen als deel van de reguliere expressie, in plaats van een vlag argument door te geven aan dere.compile() functie. Vlaggen moeten als eerste in de expressiestring worden gebruikt.

  (?:...)

  Een niet-afvangende versie van reguliere haakjes. Komt overeen met elke reguliere expressie die zich binnen de haakjes bevindt, maar de door de groep gematchte substring kan niet worden opgehaald na het uitvoeren van een overeenkomst of waarnaar later in het patroon wordt verwezen.

  (?aiLmsux-imsx:...)

  (Nul of meer letters uit de reeks 'a', 'i', 'L', 'm','s', 'u', 'x', optioneel gevolgd door '-' gevolgd door een of meer letters uit de reeks 'i', 'm', 's', 'x'.)De letters zetten of verwijderen de corresponderende vlaggen:re.A (ASCII-only matching), re.I (hoofdletters negeren),re.L (locale afhankelijk), re.M (multi-line), re.S (punt komt overeen met alles), re.U (Unicode matching), en re.X (verbose), voor het deel van de expressie.(De vlaggen worden beschreven in Module Inhoud.)

  De letters 'a', 'L' en 'u' zijn wederzijds exclusief wanneer ze gebruikt worden als inline vlaggen, dus ze kunnen niet gecombineerd worden of volgen op '-'. In plaats daarvan, wanneer een van hen in een inline groep verschijnt, overruled het de matching mode in de omringende groep. In Unicode patronen schakelt (?a:...) over naar alleen ASCII matching, en (?u:...) schakelt over naar Unicode matching (standaard). In byte-patronen schakelt (?L:...) over naar locale-afhankelijke matching, en (?a:...) schakelt over naar ASCII-only matching (standaard). Deze overschrijving is alleen van kracht voor de nauwe inline-groep, en de oorspronkelijke matching-modus wordt hersteld buiten de groep.

  Nieuw in versie 3.6.

  Gewijzigd in versie 3.7: de letters 'a', 'L' en 'u' kunnen ook in een groep worden gebruikt.

  (?P<name>...)

  Gelijk aan gewone haakjes, maar de door de groep gematchte substring is toegankelijk via de symbolische naam van de groepsnaam. Groepsnamen moeten geldige Python-identifiers zijn, en elke groepnaam mag slechts eenmaal binnen een reguliere uitdrukking worden gedefinieerd. Een symbolische groep is ook een genummerde groep, net alsof de groep geen naam zou hebben.

  Groepen met een naam kunnen in drie contexten worden genoemd. Als het patroon(?P<quote>).*?(?P=quote) is (d.w.z. overeenkomt met een tekenreeks tussen enkele of dubbele aanhalingstekens):

  Context van verwijzing naar groep “quote”	Wijze waarop ernaar kan worden verwezen
  in hetzelfde patroon zelf	(?P=quote) (zoals afgebeeld)
  bij het verwerken van luciferobject m	m.group('quote') m.end('quote') (enz.)
  in een string die wordt doorgegeven aan het replargument van re.sub()	\g<quote> \g<1>

  (?P=name)

  Een terugverwijzing naar een genoemde groep; Deze komt overeen met de tekst die overeenkwam met de naam van de vorige groep.

  (?#...)

  Een commentaar; de inhoud van de haakjes wordt gewoon genegeerd.

  (?=...)

  Matcht als ... als volgende overeenkomt, maar neemt niets van de string in beslag. Dit wordt een lookahead assertion genoemd. Bijvoorbeeld, Isaac (?=Asimov) zal alleen overeenkomen met'Isaac ' als het wordt gevolgd door 'Asimov'.

  (?!...)

  Volgt als ... niet overeenkomt met de volgende. Dit is een negatieve lookahead bewering. Bijvoorbeeld, Isaac (?!Asimov) zal alleen overeenkomen met 'Isaac ' als het niet wordt gevolgd door 'Asimov'.

  (?<=...)

  Matcht als de huidige positie in de string wordt voorafgegaan door een overeenkomst voor ... die eindigt op de huidige positie. Dit wordt een positieve lookbehindassertion genoemd. (?<=abc)def zal een overeenkomst vinden in 'abcdef', omdat de lookbehind 3 tekens teruggaat en controleert of het ingesloten patroon overeenkomt. Het ingesloten patroon mag alleen overeenkomen met tekenreeksen van een vaste lengte, wat betekent databc of a|b zijn toegestaan, maar a* en a{3,4} zijn dat niet. Merk op dat patronen die beginnen met positieve lookbehind-bevestigingen niet zullen overeenkomen aan het begin van de tekenreeks die wordt doorzocht; u zult waarschijnlijk eerder desearch() functie willen gebruiken dan de match() functie:

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

  Dit voorbeeld zoekt naar een woord dat volgt op een koppelteken:

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

  Veranderd in versie 3.5: Ondersteuning toegevoegd voor groepsverwijzingen van vaste lengte.

  (?<!...)

  Matches als de huidige positie in de tekenreeks niet wordt voorafgegaan door een overeenkomst voor.... Dit wordt een negatieve lookbehind assertie genoemd. Vergelijkbaar met positieve lookbehind asserties, moet het ingesloten patroon alleen overeenkomen met tekenreeksen van een vaste lengte. Patronen die beginnen met negatieve lookbehind asserties kunnen overeenkomen aan het begin van de string die wordt doorzocht.

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

  Probeert overeen te komen met yes-pattern als de groep met de gegeven id of naam bestaat, en met no-pattern als dat niet het geval is. no-pattern is optioneel en kan worden weggelaten. (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) is bijvoorbeeld een slecht patroon voor het matchen van e-mail, dat overeenkomt met zowel '<[email protected]>' als '[email protected]', maar niet met '<[email protected]' of '[email protected]>'.

  De speciale reeksen bestaan uit '\' en een teken uit de onderstaande lijst. Als het gewone teken geen ASCII-cijfer of ASCII-letter is, dan komt de resulterende RE overeen met het tweede teken. Bijvoorbeeld, $ komt overeen met het teken '$'.

  \number

  Vergelijkt de inhoud van de groep met hetzelfde nummer. Groepen zijn genummerd vanaf 1. Bijvoorbeeld, (.+) komt overeen met 'the the' of '55 55', maar niet met 'thethe' (let op de spatie na de groep). Deze speciale reeks kan alleen worden gebruikt om overeen te komen met een van de eerste 99 groepen. Als het eerste cijfer van een getal 0 is, of als het getal 3 octale cijfers lang is, zal het niet worden geïnterpreteerd als een groepswedstrijd, maar als het teken met octale waarde getal. Binnen de'' van een tekenklasse, worden alle numerieke escapes behandeld als tekens.

  \A

  Matcht alleen aan het begin van de tekenreeks.

  \b

  Matcht de lege tekenreeks, maar alleen aan het begin of einde van een woord.Een woord is gedefinieerd als een reeks woordkarakters. Merk op dat formeel, \b is gedefinieerd als de grens tussen een \w en een \W teken (of vice versa), of tussen \w en het begin/einde van de string.Dit betekent dat r'\bfoo\b' overeenkomt met 'foo', 'foo.', '(foo)','bar foo baz' maar niet met 'foobar' of 'foo3'.

  De standaard Unicode alfanumerieke tekens zijn die welke gebruikt worden in Unicode patronen, maar dit kan veranderd worden door de ASCII vlag te gebruiken. Woordgrenzen worden bepaald door de huidige locale als de LOCALE vlag wordt gebruikt.Binnen een tekenbereik, \b vertegenwoordigt het backspace teken, voor compatibiliteit met Python’s string literals.

  \B

  Volgt de lege tekenreeks, maar alleen als het niet aan het begin of einde van een woord staat. Dit betekent dat r'py\B' overeenkomt met 'python', 'py3', 'py2', maar niet met 'py', 'py.', of 'py!'.\B is precies het tegenovergestelde van \b, dus woordkarakters in Unicodepatterns zijn Unicode alfanumerieke tekens of de underscore, hoewel dit kan worden veranderd met behulp van de ASCII vlag. Woordgrenzen worden bepaald door de huidige locale als de LOCALE vlag wordt gebruikt.

  \d Voor Unicode (str) patronen:

  Vergelijkt elk decimaal Unicode-cijfer (dat wil zeggen, elk teken in de Unicode-tekencategorie). Dit omvat , en ook vele andere cijfertekens. Als de vlag ASCII wordt gebruikt, wordt alleen gematcht.

  Voor 8-bits (bytes) patronen:

  Vangt elk decimaal cijfer; dit is gelijkwaardig aan .

  \D

  Vangt elk teken dat geen decimaal cijfer is. Dit is het tegenovergestelde van \d. Als de vlag ASCII wordt gebruikt, wordt dit het equivalent van .

  \s Voor Unicode (str) patronen:

  Volgt Unicode witruimtekens (waaronder, en ook veel andere tekens, bijvoorbeeld de door typografische regels in veel talen voorgeschreven on-breuke spaties). Als de vlag ASCII wordt gebruikt, wordt alleen gematched.

  Voor 8-bit (bytes) patronen:

  Volgt tekens die in de ASCII-tekenset als witruimte worden beschouwd; dit is equivalent aan .

  \S

  Volgt elk teken dat geen witruimteteken is. Dit is het tegenovergestelde van \s. Als de vlag ASCII wordt gebruikt, wordt dit het equivalent van .

  \w Voor Unicode (str) patronen:

  Volgt Unicode woordkarakters; dit omvat de meeste karakters die deel kunnen uitmaken van een woord in elke taal, alsmede cijfers en de underscore. Als de vlag ASCII wordt gebruikt, wordt alleen gematcht.

  Voor 8-bits (bytes) patronen:

  Volgt tekens die als alfanumeriek worden beschouwd in de ASCII-tekenset; dit is gelijkwaardig aan . Als de vlag LOCALE wordt gebruikt, worden tekens die in de huidige locale als alfanumeriek worden beschouwd, gecombineerd met de underscore.

  \W

  Vergeldt elk teken dat geen woord-teken is. Dit is het tegenovergestelde van \w. Als de vlag ASCII wordt gebruikt, wordt dit het equivalent van . Als de vlag LOCALE wordt gebruikt, worden tekens die noch alfanumeriek zijn in de huidige localen, noch de underscore.

  \Z

  Valst alleen aan het eind van de tekenreeks.

  De meeste standaard escapes die door Python string-literals worden ondersteund, worden ook geaccepteerd door de reguliere expressieparser:

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

  (Merk op dat \b wordt gebruikt om woordgrenzen weer te geven, en alleen “backspace” betekent binnen tekenklassen.)

  '\u', '\U', en '\N' escape-sequences worden alleen herkend in Unicodepatterns. In bytes-patronen zijn het fouten. Onbekende escapes van ASCIIletters worden gereserveerd voor toekomstig gebruik en behandeld als fouten.

  Octal escapes worden in een beperkte vorm opgenomen. Als het eerste cijfer een 0 is, of als er drie octale cijfers zijn, wordt het beschouwd als een octal escape. Anders is het een groepsverwijzing. Net als bij string-literalen zijn octale escapes altijd maximaal drie cijfers lang.

  Veranderd in versie 3.3: De escape-sequenties '\u' en '\U' zijn toegevoegd.

  Veranderd in versie 3.6: Onbekende escapes bestaande uit '\' en een ASCII-letter zijn nu fouten.

  Veranderd in versie 3.8: De escape-sequentie '\N{name}' is toegevoegd. Net als in string-literalen wordt deze uitgebreid naar het genoemde Unicode-teken (bijv. '\N{EM DASH}').