Moottorin salat paljastuvat: Syväsukellus Pythonin säännöllisten lausekkeiden vastaavuusalgoritmeihin

Säännölliset lausekkeet, eli regex, ovat modernin ohjelmistokehityksen kulmakivi. Lukemattomille ohjelmoijille ympäri maailmaa ne ovat ensisijainen työkalu tekstin käsittelyyn, datan validointiin ja lokien jäsentämiseen. Käytämme niitä tiedon etsimiseen, korvaamiseen ja poimimiseen tarkkuudella, johon yksinkertaiset merkkijonometodit eivät pysty. Silti monille regex-moottori on musta laatikko – maaginen työkalu, joka ottaa vastaan kryptisen kuvion ja merkkijonon ja jotenkin tuottaa tuloksen. Tämä ymmärryksen puute voi johtaa tehottomaan koodiin ja joissakin tapauksissa katastrofaalisiin suorituskykyongelmiin.

Tämä artikkeli avaa Pythonin re-moduulin saloja. Sukellamme sen hahmontunnistusmoottorin ytimeen ja tutkimme sitä pyörittäviä perusalgoritmeja. Ymmärtämällä miten moottori toimii, opit kirjoittamaan tehokkaampia, vankempia ja ennustettavampia säännöllisiä lausekkeita, muuttaen tämän tehokkaan työkalun käytön arvailusta tieteeksi.

Säännöllisten lausekkeiden ydin: Mikä on regex-moottori?

Pohjimmiltaan säännöllisten lausekkeiden moottori on ohjelmisto, joka ottaa kaksi syötettä: kuvion (regex) ja syötemerkkijonon. Sen tehtävä on selvittää, löytyykö kuvio merkkijonosta. Jos löytyy, moottori raportoi onnistuneen vastaavuuden ja antaa usein tietoja, kuten vastaavan tekstin alku- ja loppukohdat sekä mahdolliset kaappausryhmät.

Vaikka tavoite on yksinkertainen, toteutus ei ole. Regex-moottorit perustuvat yleensä yhteen kahdesta perustavanlaatuisesta algoritmisesta lähestymistavasta, jotka juontavat juurensa teoreettiseen tietojenkäsittelytieteeseen, erityisesti äärellisten automaattien teoriaan.

• Tekstiohjatut moottorit (DFA-pohjaiset): Nämä moottorit, jotka perustuvat deterministisiin äärellisiin automaatteihin (DFA), käsittelevät syötemerkkijonoa merkki kerrallaan. Ne ovat uskomattoman nopeita ja tarjoavat ennustettavan, lineaarisen ajan suorituskyvyn. Niiden ei koskaan tarvitse peruuttaa tai arvioida uudelleen merkkijonon osia. Tämä nopeus tulee kuitenkin ominaisuuksien kustannuksella; DFA-moottorit eivät voi tukea edistyneitä rakenteita, kuten takaisinviittauksia tai laiskoja kvanttoreita. Työkalut, kuten `grep` ja `lex`, käyttävät usein DFA-pohjaisia moottoreita.
• Regex-ohjatut moottorit (NFA-pohjaiset): Nämä moottorit, jotka perustuvat epädeterministisiin äärellisiin automaatteihin (NFA), ovat kuvio-ohjattuja. Ne etenevät kuvion läpi yrittäen sovittaa sen osia merkkijonoon. Tämä lähestymistapa on joustavampi ja tehokkaampi, tukien laajaa valikoimaa ominaisuuksia, kuten kaappausryhmiä, takaisinviittauksia ja lookaround-rakenteita. Useimmat nykyaikaiset ohjelmointikielet, kuten Python, Perl, Java ja JavaScript, käyttävät NFA-pohjaisia moottoreita.

Pythonin re-moduuli käyttää perinteistä NFA-pohjaista moottoria, joka nojaa keskeiseen mekanismiin nimeltä peruuttaminen (backtracking). Tämä suunnitteluvalinta on avain sekä sen tehokkuuteen että sen potentiaalisiin suorituskykyansoihin.

Kahden automaatin tarina: NFA vs. DFA

Jotta todella ymmärtäisi, miten Pythonin regex-moottori toimii, on hyödyllistä verrata kahta hallitsevaa mallia. Ajattele niitä kahtena eri strategiana navigoida sokkelossa (syötemerkkijono) käyttäen karttaa (regex-kuvio).

Deterministinen äärellinen automaatti (DFA): Vankkumaton polku

Kuvittele kone, joka lukee syötemerkkijonoa merkki kerrallaan. Se on millä tahansa hetkellä täsmälleen yhdessä tilassa. Jokaista lukemaansa merkkiä kohden on vain yksi mahdollinen seuraava tila. Ei ole epäselvyyttä, ei valintoja, ei paluuta taaksepäin. Tämä on DFA.

• Miten se toimii: DFA-pohjainen moottori rakentaa tilakoneen, jossa jokainen tila edustaa joukkoa mahdollisia paikkoja regex-kuviossa. Se käsittelee syötemerkkijonoa vasemmalta oikealle. Jokaisen merkin lukemisen jälkeen se päivittää nykyisen tilansa deterministisen siirtymätaulukon perusteella. Jos se saavuttaa merkkijonon lopun ollessaan "hyväksyvässä" tilassa, vastaavuus on onnistunut.
• Vahvuudet:
  • Nopeus: DFA:t käsittelevät merkkijonoja lineaarisessa ajassa, O(n), jossa n on merkkijonon pituus. Kuvion monimutkaisuus ei vaikuta hakuaikaan.
  • Ennustettavuus: Suorituskyky on johdonmukainen eikä koskaan huonone eksponentiaaliseen aikaan.
• Heikkoudet:
  • Rajoitetut ominaisuudet: DFA:iden deterministinen luonne tekee mahdottomaksi toteuttaa ominaisuuksia, jotka vaativat aiemman vastaavuuden muistamista, kuten takaisinviittauksia (esim. (\w+)\s+\1). Laiskoja kvanttoreita ja lookaround-rakenteita ei myöskään yleensä tueta.
  • Tilojen räjähdysmäinen kasvu: Monimutkaisen kuvion kääntäminen DFA:ksi voi joskus johtaa eksponentiaalisen suureen määrään tiloja, mikä kuluttaa merkittävästi muistia.

Epädeterministinen äärellinen automaatti (NFA): Mahdollisuuksien polku

Kuvittele nyt toisenlainen kone. Kun se lukee merkin, sillä voi olla useita mahdollisia seuraavia tiloja. On kuin kone voisi kloonata itsensä tutkiakseen kaikkia polkuja samanaikaisesti. NFA-moottori simuloi tätä prosessia, tyypillisesti kokeilemalla yhtä polkua kerrallaan ja peruuttamalla, jos se epäonnistuu. Tämä on NFA.

• Miten se toimii: NFA-moottori käy läpi regex-kuviota, ja jokaisen kuvion osan kohdalla se yrittää sovittaa sitä merkkijonon nykyiseen kohtaan. Jos osa sallii useita mahdollisuuksia (kuten vaihtoehto | tai kvanttori *), moottori tekee valinnan ja tallentaa muut mahdollisuudet myöhempää käyttöä varten. Jos valittu polku ei johda täydelliseen vastaavuuteen, moottori peruuttaa (backtracks) viimeisimpään valintapisteeseen ja kokeilee seuraavaa vaihtoehtoa.
• Vahvuudet:
  • Tehokkaat ominaisuudet: Tämä malli tukee rikasta ominaisuusjoukkoa, mukaan lukien kaappausryhmät, takaisinviittaukset, lookahead- ja lookbehind-rakenteet sekä sekä ahneet että laiskat kvanttorit.
  • Ilmaisuvoimaisuus: NFA-moottorit pystyvät käsittelemään laajempaa valikoimaa monimutkaisia kuvioita.
• Heikkoudet:
  • Suorituskyvyn vaihtelu: Parhaassa tapauksessa NFA-moottorit ovat nopeita. Pahimmassa tapauksessa peruutusmekanismi voi johtaa eksponentiaaliseen aikakompleksisuuteen, O(2^n), ilmiöön, joka tunnetaan nimellä "katastrofaalinen peruuttaminen".

Pythonin `re`-moduulin sydän: Peruuttava NFA-moottori

Pythonin regex-moottori on klassinen esimerkki peruuttavasta NFA:sta. Tämän mekanismin ymmärtäminen on tärkein yksittäinen käsite tehokkaiden säännöllisten lausekkeiden kirjoittamisessa Pythonissa. Käytetään analogiaa: kuvittele olevasi sokkelossa ja sinulla on joukko ohjeita (kuvio). Seuraat yhtä polkua. Jos osut umpikujaan, palaat takaisin viimeiseen risteykseen, jossa sinulla oli valinnanvaraa, ja kokeilet toista polkua. Tämä "palaa ja yritä uudelleen" -prosessi on peruuttamista.

Askel-askeleelta peruuttamisesimerkki

Katsotaan, miten moottori käsittelee näennäisen yksinkertaista kuviota. Tämä esimerkki havainnollistaa ahneen vastaavuuden ja peruuttamisen peruskäsitettä.

• Kuvio: a.*b
• Merkkijono: axbyc_bzd

Tavoitteena on löytää alimerkkijono, joka alkaa 'a':lla, päättyy 'b':hen ja jonka välissä on mitä tahansa.

1. Moottori aloittaa merkkijonon ensimmäisestä merkistä. Kuvion ensimmäinen osa on a. Se vastaa merkkijonon alussa olevaa 'a':ta. Moottorin sijainti on nyt 'a':n jälkeen.
2. Seuraavana on .*. *-kvanttori on oletuksena ahne. Tämä on kriittinen kohta. Ahne kvanttori vastaa niin monta merkkiä kuin mahdollista. Joten, .* kuluttaa koko loppumerkkijonon: `xbyc_bzd`.
3. Moottori on nyt saavuttanut kuvion .*-osan lopun ja yrittää sovittaa seuraavaa osaa: b. Se on kuitenkin jo merkkijonon lopussa. Yhtään merkkiä ei ole jäljellä sovitettavaksi. Vastaavuus epäonnistuu tässä kohdassa.
4. PERUUTUS! Moottorin on harkittava uudelleen viimeistä valintaansa. Viimeinen suuri valinta oli, kuinka monta merkkiä ahne .* kuluttaisi. Se oli liian ahne. Joten se peruuttaa: .* antaa takaisin yhden merkin.
   • .*:n kuluttama merkkijono on nyt `xbyc_bz`.
   • Takaisin annettu merkki on `d`.
   • Moottori yrittää sovittaa b:tä `d`:hen. Tämä epäonnistuu.
5. UUSI PERUUTUS! .* antaa takaisin toisen merkin.
   • .*:n kuluttama merkkijono on nyt `xbyc_b`.
   • Takaisin annettu merkki on `z`.
   • Moottori yrittää sovittaa b:tä `z`:hen. Tämä epäonnistuu.
6. UUSI PERUUTUS! .* antaa takaisin toisen merkin.
   • .*:n kuluttama merkkijono on nyt `xbyc_`.
   • Takaisin annettu merkki on `b`.
   • Moottori yrittää sovittaa b:tä `b`:hen. Onnistui!
7. Koko kuvio a.*b on nyt löytynyt. Lopullinen vastaavuus on axbyc_b.

Tämä yksinkertainen esimerkki näyttää moottorin yritys-ja-erehdys-luonteen. Monimutkaisilla kuvioilla ja pitkillä merkkijonoilla tämä kuluttamisen ja takaisin antamisen prosessi voi tapahtua tuhansia tai jopa miljoonia kertoja, johtaen vakaviin suorituskykyongelmiin.

Peruuttamisen vaara: Katastrofaalinen peruuttaminen

Katastrofaalinen peruuttaminen on erityinen, pahimman tapauksen skenaario, jossa moottorin kokeiltavien permutaatioiden määrä kasvaa eksponentiaalisesti. Tämä voi aiheuttaa ohjelman jumiutumisen, kuluttaen 100 % suorittimen ytimestä sekuntien, minuuttien tai jopa pidempään, luoden tehokkaasti säännöllisten lausekkeiden palvelunestohyökkäyksen (ReDoS) haavoittuvuuden.

Tämä tilanne syntyy tyypillisesti kuviosta, jossa on sisäkkäisiä kvanttoreita päällekkäisellä merkkijoukolla, ja sitä sovelletaan merkkijonoon, joka melkein, mutta ei aivan, vastaa kuviota.

Tarkastellaan klassista patologista esimerkkiä:

• Kuvio: (a+)+z
• Merkkijono: aaaaaaaaaaaaaaaaaaaaaaaaaz (25 'a'-merkkiä ja yksi 'z')

Tämä löytää vastaavuuden erittäin nopeasti. Ulompi (a+)+ vastaa kaikkiin 'a'-merkkeihin kerralla, ja sitten z vastaa 'z':hen.

Mutta tarkastellaan nyt tätä merkkijonoa:

• Merkkijono: aaaaaaaaaaaaaaaaaaaaaaaaab (25 'a'-merkkiä ja yksi 'b')

Tästä syystä tämä on katastrofaalista:

1. Sisäinen a+ voi vastata yhteen tai useampaan 'a'-merkkiin.
2. Ulompi +-kvanttori sanoo, että ryhmä (a+) voidaan toistaa yhden tai useamman kerran.
3. Vastatakseen 25 'a'-merkin merkkijonoon, moottorilla on monia, monia tapoja jakaa se osiin. Esimerkiksi:
   • Ulompi ryhmä vastaa kerran, ja sisäinen a+ vastaa kaikkiin 25 'a'-merkkiin.
   • Ulompi ryhmä vastaa kahdesti, ja sisäinen a+ vastaa ensin 1 'a'-merkkiin ja sitten 24 'a'-merkkiin.
   • Tai 2 'a'-merkkiin ja sitten 23 'a'-merkkiin.
   • Tai ulompi ryhmä vastaa 25 kertaa, ja sisäinen a+ vastaa yhteen 'a'-merkkiin joka kerta.

Moottori yrittää ensin ahneinta vastaavuutta: ulompi ryhmä vastaa kerran ja sisäinen a+ kuluttaa kaikki 25 'a'-merkkiä. Sitten se yrittää sovittaa z:aa b:hen. Se epäonnistuu. Joten se peruuttaa. Se kokeilee seuraavaa mahdollista 'a'-merkkien ositusta. Ja seuraavaa. Ja seuraavaa. Tapojen määrä jakaa 'a'-merkkien jono on eksponentiaalinen. Moottorin on pakko kokeilla jokaista niistä ennen kuin se voi päätellä, että merkkijono ei vastaa kuviota. Vain 25 'a'-merkillä tämä voi viedä miljoonia askelia.

Kuinka tunnistaa ja estää katastrofaalinen peruuttaminen

Avain tehokkaan regexin kirjoittamiseen on ohjata moottoria ja vähentää sen tarvitsemien peruutusaskelten määrää.

1. Vältä sisäkkäisiä kvanttoreita päällekkäisillä kuvioilla
Katastrofaalisen peruuttamisen pääsyy on kuvio kuten (a*)*, (a+|b+)* tai (a+)+. Tarkastele kuvioitasi tämän rakenteen varalta. Usein sen voi yksinkertaistaa. Esimerkiksi (a+)+ on toiminnallisesti identtinen paljon turvallisemman a+:n kanssa. Kuvio (a|b)+ on paljon turvallisempi kuin (a+|b+)*.

2. Tee ahneista kvanttoreista laiskoja (ei-ahneita)
Oletuksena kvanttorit (*, +, {m,n}) ovat ahneita. Voit tehdä niistä laiskoja lisäämällä ?. Laiska kvanttori vastaa niin vähän merkkejä kuin mahdollista, laajentaen vastaavuuttaan vain, jos se on välttämätöntä loppukuvion onnistumiselle.

• Ahne: <h1>.*</h1> on the string "<h1>Title 1</h1> <h1>Title 2</h1>" will match the entire string from the first <h1> to the last </h1>.
• Laiska: <h1>.*?</h1> samalla merkkijonolla vastaa ensin "<h1>Title 1</h1>". Tämä on usein haluttu toiminta ja voi merkittävästi vähentää peruuttamista.

3. Käytä omistavia kvanttoreita ja atomisia ryhmiä (kun mahdollista)
Jotkut edistyneet regex-moottorit tarjoavat ominaisuuksia, jotka nimenomaisesti kieltävät peruuttamisen. Vaikka Pythonin standardi re-moduuli ei tue niitä, erinomainen kolmannen osapuolen regex-moduuli tukee, ja se on arvokas työkalu monimutkaiseen hahmontunnistukseen.

• Omistavat kvanttorit (`*+`, `++`, `?+`): Nämä ovat kuin ahneita kvanttoreita, mutta kun ne ovat löytäneet vastaavuuden, ne eivät koskaan anna takaisin merkkejä. Moottori ei saa peruuttaa niiden sisään. Kuvio (a++)+z epäonnistuisi lähes välittömästi ongelmallisella merkkijonollamme, koska a++ kuluttaisi kaikki 'a'-merkit ja kieltäytyisi sitten peruuttamasta, mikä aiheuttaisi koko vastaavuuden epäonnistumisen heti.
• Atomiset ryhmät `(?>...)`:** Atominen ryhmä on ei-kaappaava ryhmä, joka, kun siitä on poistuttu, hylkää kaikki peruutusasemat sen sisällä. Moottori ei voi peruuttaa ryhmän sisään kokeillakseen eri permutaatioita. `(?>a+)z` käyttäytyy samankaltaisesti kuin `a++z`.

import re

# Let's analyze the pattern 'a(b|c)+d'
re.compile('a(b|c)+d', re.DEBUG)

LITERAL 97          # Vastaa merkkiä 'a'
MAX_REPEAT 1 65535  # Aloita kvanttori: vastaa seuraavaa ryhmää 1-monta kertaa
  SUBPATTERN 1 0 0    # Aloita kaappausryhmä 1
    BRANCH            # Aloita vaihtoehto ('|'-merkki)
      LITERAL 98      # Ensimmäisessä haarassa, vastaa 'b'
    OR
      LITERAL 99      # Toisessa haarassa, vastaa 'c'
    MARK 1            # Lopeta kaappausryhmä 1
LITERAL 100         # Vastaa merkkiä 'd'
SUCCESS             # Koko kuvio on vastannut onnistuneesti