Ako používať modul regulárnych výrazov v jazyku Python re (match, search, sub atď.)

Na spracovanie regulárnych výrazov v jazyku Python používame modul re zo štandardnej knižnice. Umožňuje extrahovať, nahrádzať a deliť reťazce pomocou vzorov regulárnych výrazov.

• re — Regular expression operations — Python 3.10.0 Documentation
• Regular Expression HOWTO — Python 3.10.0 Documentation

V tejto časti najprv vysvetlíme funkcie a metódy modulu re.

• Kompilácia vzorov regulárnych výrazov:compile()
• objekt zápasu
• Skontrolujte, či sa začiatok reťazca zhoduje, extrahujte:match()
• Skontrolujte, či sa zápasy neobmedzujú len na začiatok:search()
• Kontrola zhody celého reťazca:fullmatch()
• Získajte zoznam všetkých zodpovedajúcich dielov:findall()
• Získať všetky zodpovedajúce časti ako iterátor:finditer()
• Vymeňte zodpovedajúci diel:sub(),subn()
• Rozdelenie reťazcov pomocou vzorov regulárnych výrazov:split()

Potom vysvetlím metaznaky (špeciálne znaky) a špeciálne sekvencie regulárnych výrazov, ktoré možno použiť v module re. V podstate ide o štandardnú syntax regulárnych výrazov, ale pozor na nastavenie príznakov (najmä re.ASCII).

• Metaznaky regulárnych výrazov, špeciálne sekvencie a upozornenia v jazyku Python
• Nastavenie vlajky
  • Obmedzené na znaky ASCII:re.ASCII
  • Nezáleží na veľkosti písmen:re.IGNORECASE
  • Priraďte začiatok a koniec každého riadku:re.MULTILINE
  • Zadanie viacerých príznakov
• Chamtivé a nechamtivé zápasy

Zostavenie vzoru regulárneho výrazu: compile()

Spracovanie regulárnych výrazov v module re je možné vykonať dvoma spôsobmi.

Spustiť s funkciou

Prvým je funkcia.re.match(),re.sub()Takéto funkcie sú k dispozícii na vykonávanie extrakcie, nahradenia a ďalších procesov pomocou vzorov regulárnych výrazov.

Podrobnosti funkcií budú opísané neskôr, ale vo všetkých je prvým argumentom reťazec vzoru regulárneho výrazu, za ktorým nasleduje reťazec, ktorý sa má spracovať, a tak ďalej. Napríklad v funkcii re.sub(), ktorá vykonáva substitúciu, je druhým argumentom substitučný reťazec a tretím argumentom je reťazec, ktorý sa má spracovať.

import re

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'([a-z]+)@([a-z]+)\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = re.sub(r'([a-z]+)@([a-z]+)\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

Všimnite si, že [a-z] vo vzore regulárneho výrazu v tomto príklade znamená ľubovoľný znak od a po z (t. j. malé písmená abecedy) a + znamená opakovanie predchádzajúceho vzoru (v tomto prípade [a-z]) jeden alebo viackrát. Vzorec [a-z]+ zodpovedá akémukoľvek reťazcu, ktorý opakuje jeden alebo viac znakov malej abecedy.

. je meta znak (znak so špeciálnym významom) a musí byť escapovaný spätným lomítkom.

Keďže reťazce vzorov regulárnych výrazov často používajú veľa spätných lomiek, je vhodné používať nespracované reťazce ako v príklade.

Spustí sa v metóde objektu vzoru regulárneho výrazu

Druhým spôsobom spracovania regulárnych výrazov v module re je objektová metóda regulárnych výrazov.

Pomocou funkcie re.compile() môžete skompilovať reťazec vzorov regulárnych výrazov a vytvoriť objekt vzoru regulárneho výrazu.

p = re.compile(r'([a-z]+)@([a-z]+)\.com')

print(p)
# re.compile('([a-z]+)@([a-z]+)\\.com')

print(type(p))
# <class 're.Pattern'>

re.match(),re.sub()Rovnaký postup ako tieto funkcie možno vykonať napríklad ako metódy match(),sub() objektov regulárnych výrazov.

m = p.match(s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = p.sub('new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

Všetky funkcie re.xxx() opísané nižšie sú k dispozícii aj ako metódy objektu regulárneho výrazu.

Ak opakujete proces, ktorý používa rovnaký vzor, je efektívnejšie vygenerovať objekt regulárneho výrazu pomocou funkcie re.compile() a použiť ho v okolí.

V nasledujúcej ukážke kódu je funkcia pre pohodlie použitá bez kompilácie, ale ak chcete opakovane používať rovnaký vzor, odporúčame ju vopred skompilovať a spustiť ako metódu objektu regulárneho výrazu.

objekt zápasu

match(), search() atď. vrátia objekt match.

s = 'aaa@xxx.com'

m = re.match(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(m))
# <class 're.Match'>

Zodpovedajúci reťazec a pozícia sa získajú pomocou nasledujúcich metód objektu match.

• Získajte miesto zápasu:start(),end(),span()
• Získanie zhodného reťazca:group()
• Získajte reťazec pre každú skupinu:groups()

print(m.start())
# 0

print(m.end())
# 11

print(m.span())
# (0, 11)

print(m.group())
# aaa@xxx.com

Ak časť vzoru regulárneho výrazu uzavriete do reťazca so zátvorkami(), bude táto časť spracovaná ako skupina. V tomto prípade možno reťazec časti, ktorá vyhovuje každej skupine v funkcii groups(), získať ako tuple.

m = re.match(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.groups())
# ('aaa', 'xxx', 'com')

Kontrola zhody začiatku reťazca, extrakt: match()

match() vráti objekt match, ak začiatok reťazca zodpovedá vzoru.

Ako bolo uvedené vyššie, objekt match možno použiť na extrakciu zhodného podreťazca alebo na jednoduchú kontrolu, či došlo k zhode.

match() skontroluje iba začiatok. Ak na začiatku nie je žiadny zodpovedajúci reťazec, vráti hodnotu None.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

m = re.match(r'[a-z]+@[a-z]+\.net', s)
print(m)
# None

Kontrola zhody, ktorá nie je obmedzená na začiatok, výpis: search()

Podobne ako match() vracia objekt match, ak sa zhoduje.

Ak existuje viacero zhodných častí, vráti sa len prvá zhodná časť.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.search(r'[a-z]+@[a-z]+\.net', s)
print(m)
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

m = re.search(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

Ak chcete získať všetky zhodné časti, použite funkciu findall() alebo finditer(), ako je opísané nižšie.

Kontrola zhody celého reťazca: fullmatch()

Ak chcete skontrolovať, či sa celý reťazec zhoduje so vzorom regulárneho výrazu, použite funkciu fullmatch(). To je užitočné napríklad na kontrolu, či je reťazec platný ako e-mailová adresa alebo nie.

Ak sa zhoduje celý reťazec, vráti sa objekt zhody.

s = 'aaa@xxx.com'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

Ak existujú nezhodujúce sa časti (iba čiastočná zhoda alebo žiadna zhoda), vráti sa hodnota None.

s = '!!!aaa@xxx.com!!!'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# None

Funkcia fullmatch() bola pridaná v jazyku Python 3.4. Ak chcete urobiť to isté v predchádzajúcich verziách, použite match() a zodpovedajúci metaznak $ na konci. Ak sa celý reťazec od začiatku po koniec nezhoduje, vráti funkciu None.

s = '!!!aaa@xxx.com!!!'

m = re.match(r'[a-z]+@[a-z]+\.com$', s)
print(m)
# None

Získanie zoznamu všetkých zodpovedajúcich častí: findall()

funkcia findall() vráti zoznam všetkých zodpovedajúcich podreťazcov. Všimnite si, že prvkami zoznamu nie sú zodpovedajúce objekty, ale reťazce.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.findall(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# ['aaa@xxx.com', 'bbb@yyy.com', 'ccc@zzz.net']

Počet zhodných častí možno skontrolovať pomocou vstavanej funkcie len(), ktorá vracia počet prvkov v zozname.

print(len(result))
# 3

Zoskupenie pomocou zátvoriek() vo vzore regulárneho výrazu vráti zoznam kôpok, ktorých prvky sú reťazce každej skupiny. To je ekvivalentné funkcii groups() v objekte match.

result = re.findall(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(result)
# [('aaa', 'xxx', 'com'), ('bbb', 'yyy', 'com'), ('ccc', 'zzz', 'net')]

Skupinové zátvorky () môžu byť vnorené, takže ak chcete získať aj celú zhodu, uzavrite celú zhodu do zátvoriek ().

result = re.findall(r'(([a-z]+)@([a-z]+)\.([a-z]+))', s)
print(result)
# [('aaa@xxx.com', 'aaa', 'xxx', 'com'), ('bbb@yyy.com', 'bbb', 'yyy', 'com'), ('ccc@zzz.net', 'ccc', 'zzz', 'net')]

Ak sa nenájde žiadna zhoda, vráti sa prázdny tuple.

result = re.findall('[0-9]+', s)
print(result)
# []

Získanie všetkých zodpovedajúcich častí ako iterátor: finditer()

funkcia finditer() vráti všetky zodpovedajúce časti ako iterátor. Prvky nie sú reťazce ako v prípade funkcie findall(), ale objekty zhody, takže môžete získať pozíciu (index) zhodných častí.

Samotný iterátor nie je možné vytlačiť pomocou funkcie print() a získať tak jeho obsah. Ak použijete vstavanú funkciu next() alebo príkaz for, môžete získať obsah po jednom.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# <callable_iterator object at 0x10b0efa90>

print(type(result))
# <class 'callable_iterator'>

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

Možno ho tiež previesť na zoznam pomocou funkcie list().

l = list(re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s))
print(l)
# [<re.Match object; span=(0, 11), match='aaa@xxx.com'>, <re.Match object; span=(13, 24), match='bbb@yyy.com'>, <re.Match object; span=(26, 37), match='ccc@zzz.net'>]

print(l[0])
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(l[0]))
# <class 're.Match'>

print(l[0].span())
# (0, 11)

Ak chcete získať pozíciu všetkých zodpovedajúcich častí, je zápis s porozumením zoznamu vhodnejší ako list().

print([m.span() for m in re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)])
# [(0, 11), (13, 24), (26, 37)]

Iterátor vyberá prvky v poradí. Všimnite si, že ak sa pokúsite vybrať ďalšie prvky po dosiahnutí konca, nezostane vám nič.

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

print(list(result))
# []

Nahraďte zodpovedajúce časti: sub(), subn()

Pomocou funkcie sub() môžete nahradiñ zodpovedajúcu časť iným reťazcom. Vráti sa nahradený reťazec.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

print(type(result))
# <class 'str'>

Pri zoskupovaní pomocou funkcie zátvoriek() možno v nahradenom reťazci použiť porovnávaný reťazec.

V predvolenom nastavení sú podporované tieto možnosti: Všimnite si, že pre bežné reťazce, ktoré nie sú surovými reťazcami, musí byť pred spätným lomítkom uvedené spätné lomítko, aby sa zabránilo spätnému lomítku.

result = re.sub(r'([a-z]+)@([a-z]+)\.com', r'\1@\2.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

?P<xxx>
Ak skupinu pomenujete tak, že ju napíšete na začiatok zátvoriek vzoru regulárneho výrazu, môžete ju špecifikovať pomocou názvu namiesto čísla, ako je uvedené nižšie.
\g<xxx>

result = re.sub(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

Argument count určuje maximálny počet nahradení. Nahradí sa len počet z ľavej strany.

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# new-address, bbb@yyy.com, ccc@zzz.net

funkcia subn() vráti tuple substituovaného reťazca (rovnaký ako návratová hodnota funkcie sub()) a počet substituovaných častí (počet častí, ktoré vyhovujú vzoru).

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# ('new-address, new-address, ccc@zzz.net', 2)

Spôsob zadávania argumentov je rovnaký ako pri funkcii sub(). Môžete použiť časť zoskupenú v zátvorkách alebo zadať počet argumentov.

result = re.subn(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# ('aaa@xxx.net, bbb@yyy.net, ccc@zzz.net', 2)

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# ('new-address, bbb@yyy.com, ccc@zzz.net', 1)

Delenie reťazcov pomocou vzorov regulárnych výrazov: split()

Split() rozdelí reťazec v časti, ktorá zodpovedá vzoru, a vráti ho ako zoznam.

Všimnite si, že prvá a posledná zhoda bude obsahovať prázdne reťazce na začiatku a na konci výsledného zoznamu.

s = '111aaa222bbb333'

result = re.split('[a-z]+', s)
print(result)
# ['111', '222', '333']

result = re.split('[0-9]+', s)
print(result)
# ['', 'aaa', 'bbb', '']

Argument maxsplit určuje maximálny počet rozdelení (kusov). Rozdelí sa len počet z ľavej strany.

result = re.split('[a-z]+', s, 1)
print(result)
# ['111', '222bbb333']

Metaznaky regulárnych výrazov, špeciálne sekvencie a upozornenia v jazyku Python

Hlavné metaznaky regulárnych výrazov (špeciálne znaky) a špeciálne sekvencie, ktoré možno použiť v module Python 3 re, sú tieto

V tejto tabuľke nie sú uvedené všetky. Kompletný zoznam nájdete v oficiálnej dokumentácii.

• re — Regular expression operations — Regular Expression Syntax — Python 3.10.0 Documentation

Všimnite si tiež, že niektoré významy sú v jazyku Python 2 odlišné.

• 7.2. re — Regular expression operations — Regular Expression Syntax — Python 2.7.18 Documentation

Nastavenie vlajky

Ako je uvedené v tabuľke vyššie, niektoré meta znaky a špeciálne sekvencie menia svoj režim v závislosti od príznaku.

Sú tu zahrnuté len hlavné vlajky. Ostatné informácie nájdete v oficiálnej dokumentácii.

• re — Regular expression operations — Module Contents — Python 3.10.0 Documentation

Obmedzené na znaky ASCII: re.ASCII

\wV prípade reťazcov Pythonu 3 to bude štandardne zodpovedať aj dvojbajtovým kandži, alfanumerickým znakom atď. Nie je ekvivalentný nasledujúcemu výrazu, pretože nejde o štandardný regulárny výraz.[a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３')
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

m = re.match('[a-zA-Z0-9_]+', '漢字ＡＢＣ１２３')
print(m)
# None

Ak zadáte re.ASCII pre príznaky argumentov v každej funkcii alebo pridáte nasledujúci inline príznak na začiatok reťazca vzorov regulárnych výrazov, bude sa zhodovať len so znakmi ASCII (nebude sa zhodovať s dvojbajtovými japonskými znakmi, alfanumerickými znakmi atď.).
(?a)
V tomto prípade sú nasledujúce dve rovnocenné.
\w=[a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'(?a)\w+', '漢字ＡＢＣ１２３')
print(m)
# None

To isté platí aj pri kompilácii pomocou funkcie re.compile(). Použite argument flags alebo inline flags.

p = re.compile(r'\w+', flags=re.ASCII)
print(p)
# re.compile('\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

p = re.compile(r'(?a)\w+')
print(p)
# re.compile('(?a)\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

ASCII je k dispozícii aj ako skrátená forma re. A. Môžete použiť buď.

print(re.ASCII is re.A)
# True

\W, opak \W, je tiež ovplyvnený príznakmi re.ASCII a inline.

m = re.match(r'\W+', '漢字ＡＢＣ１２３')
print(m)
# None

m = re.match(r'\W+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

Podobne ako v prípade \w, nasledujúce dva znaky štandardne vyhovujú jednobajtovým aj dvojbajtovým znakom, ale sú obmedzené na jednobajtové znaky, ak sú zadané príznaky re.ASCII alebo inline.

• Zhodujte sa s číslami\d
• Zodpovedá prázdnemu miestu\s
• Zodpovedá nečíselným údajom\D
• Zodpovedá ľubovoľnej položke, ktorá nie je medzera.\S

m = re.match(r'\d+', '123')
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３')
print(m)
# <re.Match object; span=(0, 3), match='１２３'>

m = re.match(r'\d+', '123', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'\s+', '　')  # full-width space
print(m)
# <re.Match object; span=(0, 1), match='\u3000'>

m = re.match(r'\s+', '　', flags=re.ASCII)
print(m)
# None

Nezáleží na veľkosti písmen:re.IGNORECASE

V predvolenom nastavení sa rozlišujú veľké a malé písmená. Ak chcete priradiť obidve, musíte do vzoru zahrnúť veľké aj malé písmená.

re.IGNORECASEAk je táto možnosť zadaná, priradí sa bez ohľadu na veľkosť písmen. Ekvivalent príznaku i v štandardných regulárnych výrazoch.

m = re.match('[a-zA-Z]+', 'abcABC')
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[a-z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[A-Z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

Môžete použiť hodnotu menšiu alebo rovnú.

• inline príznak(?i)
• skratkare.I

Priraďte začiatok a koniec každého riadku:re.MULTILINE

^Meta znaky v tomto regulárnom výraze zodpovedajú začiatku reťazca.

V predvolenom nastavení sa porovná len začiatok celého reťazca, ale nasledujúci postup porovná aj začiatok každého riadku. Ekvivalent príznaku m v štandardných regulárnych výrazoch.
re.MULTILINE

s = '''aaa-xxx
bbb-yyy
ccc-zzz'''

print(s)
# aaa-xxx
# bbb-yyy
# ccc-zzz

result = re.findall('[a-z]+', s)
print(result)
# ['aaa', 'xxx', 'bbb', 'yyy', 'ccc', 'zzz']

result = re.findall('^[a-z]+', s)
print(result)
# ['aaa']

result = re.findall('^[a-z]+', s, flags=re.MULTILINE)
print(result)
# ['aaa', 'bbb', 'ccc']

$Zodpovedá koncu reťazca. V predvolenom nastavení sa porovnáva iba koniec celého reťazca.
re.MULTILINEAk to zadáte, bude sa zhodovať aj koniec každého riadku.

result = re.findall('[a-z]+$', s)
print(result)
# ['zzz']

result = re.findall('[a-z]+$', s, flags=re.MULTILINE)
print(result)
# ['xxx', 'yyy', 'zzz']

Môžete použiť hodnotu menšiu alebo rovnú.

• inline príznak(?m)
• skratkare.M

Zadanie viacerých príznakov

|Ak chcete povoliť viacero príznakov súčasne, použite túto možnosť. V prípade inline príznakov musí za každým znakom nasledovať písmeno, ako je uvedené nižšie.
(?am)

s = '''aaa-xxx
漢漢漢-字字字
bbb-zzz'''

print(s)
# aaa-xxx
# 漢漢漢-字字字
# bbb-zzz

result = re.findall(r'^\w+', s, flags=re.M)
print(result)
# ['aaa', '漢漢漢', 'bbb']

result = re.findall(r'^\w+', s, flags=re.M | re.A)
print(result)
# ['aaa', 'bbb']

result = re.findall(r'(?am)^\w+', s)
print(result)
# ['aaa', 'bbb']

Chamtivé a nechamtivé zápasy

Toto je všeobecný problém regulárnych výrazov, nielen problém jazyka Python, ale napíšem o ňom, pretože ma zvyčajne dostáva do problémov.

V predvolenom nastavení je nasledujúca zhoda „greedy match“, ktorá zodpovedá najdlhšiemu možnému reťazcu.

• *
• +
• ?

s = 'aaa@xxx.com, bbb@yyy.com'

m = re.match(r'.+com', s)
print(m)
# <re.Match object; span=(0, 24), match='aaa@xxx.com, bbb@yyy.com'>

print(m.group())
# aaa@xxx.com, bbb@yyy.com

Znak ? za ním bude mať za následok minimálnu zhodu, ktorá bude zodpovedať najkratšiemu možnému reťazcu.

• *?
• +?
• ??

m = re.match(r'.+?com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.group())
# aaa@xxx.com

Všimnite si, že predvolená chamtivá zhoda môže zodpovedať neočakávaným reťazcom.