Mootori paljastamine: sügav sukeldumine Pythoni regulaaravaldiste mustri sobitamise algoritmidesse

Regulaaravaldised ehk regexid on kaasaegse tarkvaraarenduse nurgakivi. Lugematutele programmeerijatele üle kogu maailma on need esmased tööriistad tekstide töötlemiseks, andmete valideerimiseks ja logide parsermiseks. Me kasutame neid info leidmiseks, asendamiseks ja väljavõtmiseks täpsusega, mida lihtsad stringimeetodid ei suuda pakkuda. Paljude jaoks jääb aga regex-mootor mustaks kastiks – maagiliseks tööriistaks, mis võtab vastu krüptilise mustri ja stringi ning toodab kuidagi tulemuse. See arusaamatuse puudus võib viia ebaefektiivse koodini ja mõnel juhul katastroofiliste jõudlusprobleemideni.

See artikkel avab Pythoni re mooduli telgitagused. Me sukeldume selle mustri sobitamise mootori tuuma, uurides selle taga olevaid fundamentaalseid algoritme. Mõistes, kuidas mootor töötab, saate kirjutada efektiivsemaid, vastupidavamaid ja ettearvamatumaid regulaaravaldiseid, muutes selle võimsa tööriista kasutamise oletusest teaduseks.

Regulaaravaldiste tuum: Mis on regex-mootor?

Oma olemuselt on regulaaravaldiste mootor tarkvarajupp, mis võtab vastu kaks sisendit: mustri (regulaaravaldise) ja sisendstringi. Selle ülesanne on kindlaks teha, kas muster on stringist leitav. Kui see on, teatab mootor edukast vastest ja annab sageli üksikasju, nagu sobitatud teksti algus- ja lõpppositsioonid ning kõik püütud rühmad.

Kuigi eesmärk on lihtne, ei ole selle teostus. Regex-mootorid on üldiselt ehitatud ühele kahest fundamentaalsest algoritmilisest lähenemisviisist, mis on juurdunud teoreetilises arvutiteaduses, täpsemalt lõplike automaatide teoorias.

• Tekstipõhised mootorid (DFA-põhised): Need Deterministic Finite Automata (DFA) põhimõttel töötavad mootorid töötlevad sisendstringi üks märk korraga. Need on uskumatult kiired ja pakuvad ettearvatavat, lineaaraja jõudlust. Nad ei pea kunagi tagasi pöörduma ega stringi osi uuesti hindama. Kuid see kiirus tuleb funktsioonide arvelt; DFA-mootorid ei toeta täpsemaid konstruktsioone nagu tagasiviited või laisad kvantifikaatorid. Tööriistad nagu `grep` ja `lex` kasutavad sageli DFA-põhiseid mootoreid.
• Regex-põhised mootorid (NFA-põhised): Need Nondeterministic Finite Automata (NFA) põhimõttel töötavad mootorid on mustripõhised. Nad liiguvad läbi mustri, püüdes sobitada selle komponente stringiga. See lähenemisviis on paindlikum ja võimsam, toetades laia valikut funktsioone, sealhulgas püüdmisrühmi, tagasiviiteid ja lookarounde. Enamik kaasaegseid programmeerimiskeeli, sealhulgas Python, Perl, Java ja JavaScript, kasutavad NFA-põhiseid mootoreid.

Pythoni re moodul kasutab traditsioonilist NFA-põhist mootorit, mis tugineb kriitilisele mehhanismile nimega tagasisammumine. See disainivalik on võtmeks nii selle võimsusele kui ka potentsiaalsetele jõudlusprobleemidele.

Kahe automaadi lugu: NFA vs. DFA

Selleks, et tõeliselt mõista, kuidas Pythoni regex-mootor töötab, on kasulik võrrelda kahte domineerivat mudelit. Kujutage neid ette kui kahte erinevat strateegiat labürindis (sisendstring) navigeerimiseks kaardi (regex-muster) abil.

Deterministlikud lõplikud automaadid (DFA): Vankumatu tee

Kujutage ette masinat, mis loeb sisendstringi märk-märgilt. Igal ajahetkel on see täpselt ühes olekus. Iga loetud märgi kohta on ainult üks võimalik järgmine olek. Puudub mitmetimõistetavus, valik ega tagasipöördumine. See on DFA.

• Kuidas see töötab: DFA-põhine mootor ehitab olekumasina, kus iga olek esindab võimalikku positsiooni regex-mustris. See töötleb sisendstringi vasakult paremale. Pärast iga märgi lugemist värskendab see oma praegust olekut deterministliku üleminekutabeli põhjal. Kui see jõuab stringi lõppu "aktsepteerivas" olekus, on vaste edukas.
• Tugevused:
  • Kiirus: DFA-d töötlevad stringe lineaarses ajas, O(n), kus n on stringi pikkus. Mustri keerukus ei mõjuta otsinguaega.
  • Ettemääratavus: Jõudlus on püsiv ja ei lange kunagi eksponentsiaalseks ajaks.
• Nõrkused:
  • Piiratud funktsioonid: DFA-de deterministlik olemus muudab võimatuks juurutada funktsioone, mis nõuavad eelmise vaste meeldejätmist, nagu tagasiviited (nt (\w+)\s+\1). Laisad kvantifikaatorid ja lookaround'id ei ole samuti üldiselt toetatud.
  • Olekuplahvatus: Keerulise mustri kompileerimine DFA-ks võib mõnikord viia eksponentsiaalselt suure hulga olekuteni, tarbides oluliselt mälu.

Mittedeterministlikud lõplikud automaadid (NFA): Võimaluste tee

Nüüd kujutage ette teistsugust masinat. Kui see loeb märki, võib sellel olla mitu võimalikku järgmist olekut. See on justkui masin saaks ennast kloonida, et uurida kõiki teid samaaegselt. NFA-mootor simuleerib seda protsessi, tavaliselt proovides ühte teed korraga ja pöördudes tagasi, kui see ebaõnnestub. See on NFA.

• Kuidas see töötab: NFA-mootor läbib regex-mustrit ja iga mustri tokeni jaoks proovib see seda sobitada stringi praeguse positsiooniga. Kui token võimaldab mitut võimalust (nagu alternatsioon `|` või kvantifikaator `*`), teeb mootor valiku ja salvestab teised võimalused hilisemaks. Kui valitud tee ei anna täielikku vastet, tagurdab mootor viimase valiku punkti juurde ja proovib järgmist alternatiivi.
• Tugevused:
  • Võimsad funktsioonid: See mudel toetab rikkalikku funktsioonikomplekti, sealhulgas püüdmisrühmi, tagasiviiteid, lookaheade, lookbehinde ning nii ahneid kui ka laisku kvantifikaatoreid.
  • Väljendusvõime: NFA-mootorid saavad hakkama laiema valiku keeruliste mustritega.
• Nõrkused:
  • Jõudluse varieeruvus: Parimal juhul on NFA-mootorid kiired. Halvimal juhul võib tagasisammumise mehhanism viia eksponentsiaalse ajakompleksuseni, O(2^n), nähtuseni, mida tuntakse kui "katastroofilist tagasisammumist".

Pythoni re mooduli süda: Tagasisammumise NFA-mootor

Pythoni regex-mootor on klassikaline näide tagasisammumise NFA-st. Selle mehhanismi mõistmine on kõige olulisem kontseptsioon Pythonis efektiivsete regulaaravaldiste kirjutamiseks. Kasutame analoogiat: kujutage ette, et olete labürindis ja teil on juhised (muster). Järgite ühte teed. Kui jõuate tupikusse, pöördute tagasi viimase risttee juurde, kus teil oli valik, ja proovite teist teed. See "tagasi pöördumise ja uuesti proovimise" protsess on tagasisammumine.

Samm-sammult tagasisammumise näide

Vaatame, kuidas mootor näiliselt lihtsa mustriga hakkama saab. See näide demonstreerib ahne sobitamise ja tagasisammumise põhikontseptsiooni.

• Muster: a.*b
• String: axbyc_bzd

Eesmärk on leida alamstring, mis algab 'a'-ga, lõpeb 'b'-ga ja mille vahel on midagi.

1. Mootor alustab stringi esimesest märgist. Mustri esimene osa on a. See sobitab stringi alguses oleva 'a'-ga. Mootori positsioon on nüüd pärast 'a'-d.
2. Järgmine on .*. Kvantifikaator * on ahne vaikimisi. See on kriitiline punkt. Ahne kvantifikaator sobitab nii palju märke kui võimalik. Niisiis, .* tarbib ära kogu ülejäänud stringi: `xbyc_bzd`.
3. Mootor on nüüd jõudnud mustri .* osa lõppu ja proovib sobitada järgmist tokenit: b. Kuid see on juba stringi lõpus. Sooritada pole enam märke. Vaste ebaõnnestub selles positsioonis.
4. TAGASISAMMUMINE! Mootor peab oma viimase valiku ümber mõtlema. Viimane suur valik oli see, kui palju märke ahne .* peaks tarbima. See oli liiga ahne. Nii et see tagurdab: .* annab ühe märgi tagasi.
   • String, mille .* tarbis, on nüüd `xbyc_bz`.
   • Tagasi antud märk on `d`.
   • Mootor proovib sobitada b-d `d`-ga. See ebaõnnestub.
5. UUESTI TAGASISAMMUMINE! .* annab veel ühe märgi tagasi.
   • String, mille .* tarbis, on nüüd `xbyc_b`.
   • Tagasi antud märk on `z`.
   • Mootor proovib sobitada b-d `z`-ga. See ebaõnnestub.
6. UUESTI TAGASISAMMUMINE! .* annab veel ühe märgi tagasi.
   • String, mille .* tarbis, on nüüd `xbyc_`.
   • Tagasi antud märk on `b`.
   • Mootor proovib sobitada b-d `b`-ga. Edu!
7. Kogu muster a.*b on nüüd sobitatud. Lõplik vaste on axbyc_b.

See lihtne näide näitab mootori katse-eksituse meetodit. Keeruliste mustrite ja pikkade stringide puhul võib see tarbimise ja tagasiandmise protsess toimuda tuhandeid või isegi miljoneid kordi, põhjustades tõsiseid jõudlusprobleeme.

Tagasisammumise oht: Katastroofiline tagasisammumine

Katastroofiline tagasisammumine on spetsiifiline, halvima stsenaariumi olukord, kus mootori proovitavate permutatsioonide arv kasvab eksponentsiaalselt. See võib põhjustada programmi hangumise, tarbides 100% CPU tuumast sekunditeks, minutiteks või isegi kauem, luues tõhusalt regulaaravaldiste teenuse keelamise (ReDoS) haavatavuse.

See olukord tekib tavaliselt mustrist, millel on pesastatud kvantifikaatorid kattuvate märgikomplektidega, rakendatuna stringile, mis peaaegu, kuid mitte täielikult, sobib.

Kaalume klassikalist patoloogilist näidet:

• Muster: (a+)+z
• String: aaaaaaaaaaaaaaaaaaaaaaaaaz (25 'a'd ja üks 'z')

See sobitub väga kiiresti. Välimine `(a+)+` sobitab kõik 'a'-d korraga ja seejärel `z` sobitab 'z'-ga.

Kuid nüüd kaalume seda stringi:

• String: aaaaaaaaaaaaaaaaaaaaaaaaab (25 'a'd ja üks 'b')

Siin on, miks see on katastroofiline:

1. Sisemine a+ saab sobitada ühe või mitu 'a'-d.
2. Välimine + kvantifikaator ütleb, et rühma (a+) saab korrata üks või mitu korda.
3. 25 'a'-st koosneva stringi sobitamiseks on mootoril palju, palju viise, kuidas seda jaotada. Näiteks:
   • Välimine rühm sobib üks kord, sisemine a+ sobitab kõik 25 'a'-d.
   • Välimine rühm sobib kaks korda, sisemine a+ sobitab 1 'a' ja seejärel 24 'a'-d.
   • Või 2 'a'-d ja seejärel 23 'a'-d.
   • Või välimine rühm sobib 25 korda, sisemine a+ sobitab iga kord ühe 'a'.

Mootor proovib esmalt kõige ahnemat vastet: välimine rühm sobitab ühe korra ja sisemine `a+` tarbib kõik 25 'a'-d. Seejärel proovib see sobitada `z`-d `b`-ga. See ebaõnnestub. Nii et see tagurdab. See proovib 'a'-de järgmist võimalikku jaotust. Ja järgmist. Ja järgmist. 'a'-de stringi jaotamise viiside arv on eksponentsiaalne. Mootor on sunnitud proovima igaüht neist, enne kui saab järeldada, et string ei sobi. Vaid 25 'a'-ga võib see võtta miljoneid samme.

Kuidas katastroofilist tagasisammumist tuvastada ja vältida

Efektiivse regexi kirjutamise võti on mootori juhtimine ja vajalike tagasisammumiste arvu vähendamine.

1. Vältige pesastatud kvantifikaatoreid kattuvate mustritega
Katastroofilise tagasisammumise peamine põhjus on muster nagu (a*)*, (a+|b+)* või (a+)+. Kontrollige oma mustreid selle struktuuri osas. Sageli saab seda lihtsustada. Näiteks (a+)+ on funktsionaalselt identne palju ohutuma a+-ga. Muster (a|b)+ on palju ohutum kui (a+|b+)*.

2. Muutke ahned kvantifikaatorid laisaks (mitte-ahnelt)
Vaikimisi on kvantifikaatorid (`*`, `+`, `{m,n}`) ahned. Saate need laisaks muuta, lisades `?`. Laisk kvantifikaator sobitab võimalikult vähe märke, laiendades oma vastet ainult siis, kui see on vajalik ülejäänud mustri edukaks sobitamiseks.

• Ahne: <h1>.*</h1> stringil "<h1>Pealkiri 1</h1> <h1>Pealkiri 2</h1>" sobitab kogu stringi esimesest <h1> kuni viimase </h1>-ni.
• Laisk: <h1>.*?</h1> samal stringil sobitab esmalt "<h1>Pealkiri 1</h1>". See on sageli soovitud käitumine ja võib oluliselt vähendada tagasisammumist.

3. Kasutage valdavalt omastavaid kvantifikaatoreid ja aatomrühmi (kui võimalik)
Mõned täiustatud regex-mootorid pakuvad funktsioone, mis keelavad tagasisammumise. Kuigi Pythoni standardne `re` moodul neid ei toeta, toetab neid suurepärane kolmanda osapoole `regex` moodul ja see on väärtuslik tööriist keeruliste mustrite sobitamiseks.

• Omastavad kvantifikaatorid (`*+`, `++`, `?+`): Need on nagu ahned kvantifikaatorid, kuid kui nad on sobitunud, ei anna nad kunagi ühtegi märki tagasi. Mootoril pole lubatud neisse tagasi minna. Muster (a++)+z ebaõnnestuks meie probleemse stringi puhul peaaegu kohe, sest `a++` tarbiks kõik 'a'-d ära ja keeldub seejärel tagasi minemast, põhjustades kogu vaste kohese ebaõnnestumise.
• Aatomrühmad `(?>...)`:** Aatomrühm on mittepüüdev rühm, mis pärast väljumist loobub kõigist tagasisammumise positsioonidest. Mootor ei saa rühma tagasi minna, et proovida erinevaid permutatsioone. `(?>a+)z` käitub sarnaselt `a++z`-ga.

import re

# Analüüsime mustrit 'a(b|c)+d'
re.compile('a(b|c)+d', re.DEBUG)

LITERAL 97          # Sobita märk 'a'
MAX_REPEAT 1 65535  # Alusta kvantifikaatorit: sobita järgmine rühm 1 kuni mitu korda
  SUBPATTERN 1 0 0    # Alusta püüdmisrühma 1
    BRANCH            # Alusta alternatsiooni ('|' märk)
      LITERAL 98      # Esimeses harus sobita 'b'
    OR
      LITERAL 99      # Teises harus sobita 'c'
    MARK 1            # Lõpeta püüdmisrühm 1
LITERAL 100         # Sobita märk 'd'
SUCCESS             # Kogu muster on edukalt sobitatud