0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 25 min

Regulární výrazy

Naučíš se hledat, kontrolovat a opravovat vzory v textu, jako jsou kódy, PSČ nebo telefony. A poznáš, kdy regex nepoužít.

Hloubka
Úkoly
Lidsky řečeno

"kočka" in text hledá konkrétního člověka podle jména. Regulární výraz je popis pro policii: „dvě velká písmena, pomlčka, čtyři číslice“. Neznáš přesnou hodnotu, ale poznáš každého, kdo popisu odpovídá.

Hledání podle vzoru

V e-mailech od zákazníků jsou čísla objednávek ve tvaru OBJ- a čtyři číslice. Metoda find umí hledat jen přesný text, jenže čísla předem neznáš. Regulární výraz (zkráceně regex) je krátký zápis vzoru a v Pythonu s ním pracuje modul re.

import re

text = "Reklamace k OBJ-2291 a OBJ-0417. Číslo OBJ-77 je neplatné."
print(re.findall(r"OBJ-\d{4}", text))
Výstup
['OBJ-2291', 'OBJ-0417']

Vzor čti zleva: doslova OBJ-, potom \d (číslice) a {4} (přesně čtyřikrát). OBJ-77 má číslice jen dvě, a tak neprošlo.

Písmeno r před uvozovkami značí surový řetězec: zpětné lomítko v něm zůstane obyčejným znakem a dostane se až k modulu re.

Abeceda vzorů

Většinu práce obstará pár značek.

VzorVýznam
.jakýkoli znak kromě konce řádku
\d \Dčíslice, a naopak cokoli jiného
\w \Wznak slova (písmeno, číslice, _), a naopak
\s \Sbílý znak (mezera, tabulátor, nový řádek), a naopak
[abc]jeden ze znaků v závorce
[a-z]jeden znak z rozsahu
[^abc]jeden znak, který v závorce není
?předchozí nula nebo jednou
*předchozí nula a vícekrát
+předchozí jednou a vícekrát
{3} {2,4}přesně 3krát, 2 až 4krát
^ $začátek a konec textu
\bhranice slova
a|ba nebo b

Znaky se zvláštním významem, když je chceš doslova, uvozuje zpětné lomítko: \. je opravdová tečka.

import re

text = "PSČ 110 00, 60200 a 7390; balení 1.5 kg, 1x5 krabic"

print(re.findall(r"\d{3} ?\d{2}", text))
print(re.findall(r"1.5", text))
print(re.findall(r"1\.5", text))
print(re.findall(r"\b\d\b", "1 22 3"))
print(re.findall(r"[A-Z]\d", "A1 b2 C3"))
Výstup
['110 00', '60200']
['1.5', '1x5']
['1.5']
['1', '3']
['A1', 'C3']

Mezera s otazníkem v prvním vzoru znamená „mezera tu být může“. Druhý řádek ukazuje nejčastější přehlédnutí: tečka bez lomítka vzala i 1x5.

Čeština je tu zvláštní případ. \w české znaky zná, ale rozsah [a-z] opravdu znamená jen písmena anglické abecedy.

import re

veta = "Žluťoučký kůň, 3 krát!"
print(re.findall(r"\w+", veta))
print(re.findall(r"[a-zA-Z]+", veta))
Výstup
['Žluťoučký', 'kůň', '3', 'krát']
['lu', 'ou', 'k', 'k', 'kr', 't']
Úkol

Najdi skladové kódy

Napiš funkci najdi_kody(text), která vrátí seznam kódů. Platný kód má 2 nebo 3 velká písmena bez diakritiky, pomlčku a přesně 4 číslice. Kód musí stát samostatně, takže ABCD-1234 ani AB-12345 se nepočítají.

import re

def najdi_kody(text):
    return []
Výstup

Funkce modulu re

Vzor je jedna věc, druhá je, co s ním chceš udělat.

FunkceCo děláVrací
re.searchnajde první výskyt kdekoliMatch nebo None
re.matchzkouší shodu jen od začátkuMatch nebo None
re.fullmatchshoda musí pokrýt celý textMatch nebo None
re.findallnajde všechny výskytyseznam
re.finditernajde všechny, postupněiterátor Match objektů
import re

kod = "abc 123"
print(re.search(r"\d+", kod))
print(re.match(r"\d+", kod))
print(re.fullmatch(r"\d+", "123"))
print(re.fullmatch(r"\d+", "123a"))
Výstup
<re.Match object; span=(4, 7), match='123'>
None
<re.Match object; span=(0, 3), match='123'>
None

Výsledek je objekt Match, nebo None, když se nic nenašlo. Ptá se na něj if, a uvnitř zjistíš podrobnosti: co se našlo a kde.

import re

uctenka = "káva 89 Kč, dort 120 Kč, voda 35 Kč"

for nalez in re.finditer(r"(\d+) Kč", uctenka):
    print(nalez.group(), "na pozici", nalez.start(), "cena", int(nalez.group(1)))
Výstup
89 Kč na pozici 5 cena 89
120 Kč na pozici 17 cena 120
35 Kč na pozici 30 cena 35
Úkol

Je to PSČ?

Napiš funkci je_psc(text), která vrátí True, když je celý text platné PSČ: tři číslice, volitelná jedna mezera, dvě číslice. Jinak vrátí False.

import re

def je_psc(text):
    return None
Výstup

Skupiny: vytáhni jen to podstatné

Kulaté závorky vytvoří skupinu. Ta si zapamatuje, co pokryla. Lepší je dát jí jméno přes (?P<jmeno>...), protože vzor se pak čte snáz a číslování se nerozsype, když přidáš další závorku.

import re

vzor = r"(?P<den>\d{1,2})\.(?P<mesic>\d{1,2})\.(?P<rok>\d{4})"
nalez = re.search(vzor, "Termín: 14.3.2026 dopoledne")

print(nalez.group())
print(nalez.group(1), nalez["rok"])
print(nalez.groupdict())
Výstup
14.3.2026
14 2026
{'den': '14', 'mesic': '3', 'rok': '2026'}

Závorky navíc určují, kam až sahá | nebo opakování. Pokud je potřebuješ jen na seskupení a ukládat nic nechceš, napiš (?:...). A to je důležité kvůli findall, který se se skupinami chová jinak: nevrací celou shodu, ale jen obsah skupin.

import re

text = "Volej 800 nebo 900, případně linku 700."

print(re.findall(r"(8|9)00", text))
print(re.findall(r"(?:8|9)00", text))
print(re.findall(r"(\w)(\d)", "a1 b2"))
Výstup
['8', '9']
['800', '900']
[('a', '1'), ('b', '2')]
Úkol

Rozlož řádek faktury

Napiš funkci rozloz(radek) pro řádky jako Faktura 2026/0042, splatnost 14.3.2026, částka 12 500 Kč. Vrátí slovník s klíči cislo (text "2026/0042"), splatnost (text "14.3.2026") a castka (celé číslo 12500, mezery v částce zmiz). Když řádek neodpovídá, vrátí None.

import re

def rozloz(radek):
    return None
Výstup

Nahrazování a dělení

re.sub nahradí všechny shody. V náhradě se na skupiny odkážeš přes \1 nebo \g<jmeno>. Místo textu můžeš předat i funkci, která dostane Match a vrátí náhradu.

import re

print(re.sub(r"\s+", " ", "příliš   mnoho \n mezer"))
print(re.sub(r"(\d{1,2})\.(\d{1,2})\.(\d{4})", r"\3-\2-\1", "od 14.3.2026"))

def iso(nalez):
    den, mesic, rok = nalez.groups()
    return f"{rok}-{int(mesic):02}-{int(den):02}"

print(re.sub(r"(\d{1,2})\.(\d{1,2})\.(\d{4})", iso, "od 14.3.2026 do 2.11.2026"))
Výstup
příliš mnoho mezer
od 2026-3-14
od 2026-03-14 do 2026-11-02

Prostá náhrada na druhém řádku jen přehází skupiny, takže měsíc zůstal bez úvodní nuly. Funkce na třetím řádku si s ním poradí.

re.split dělí text podle vzoru, takže si poradí s více různými oddělovači. A když je součástí vzoru text od uživatele, projeď ho přes re.escape, aby se jeho tečky a hvězdičky nebraly jako značky.

import re

print(re.split(r"\s*[,;]\s*", "jablka, hrušky ;švestky,  třešně"))

hledane = "C++ (2020)"
print(re.findall(re.escape(hledane), "Kurz C++ (2020) a C++ (2023)"))
Výstup
['jablka', 'hrušky', 'švestky', 'třešně']
['C++ (2020)']
Úkol

Schovej telefony

Napiš funkci zamaskuj(text), která v textu nahradí devítimístná telefonní čísla tak, že zůstanou vidět jen poslední tři číslice: 600 000 123 i 600000123 se změní na *** *** 123. Číslice mohou být ve trojicích oddělené jednou mezerou nebo bez mezer. Delší řady číslic neměň.

import re

def zamaskuj(text):
    return text
Výstup

Hladovost, příznaky a kdy regex nepoužít

Opakování je hladové: vezme co nejvíc a vrací jen tolik, kolik je nutné. Otazník za ním z něj udělá líné, které bere co nejméně. Často je ale nejčistší říct přesně, co se opakovat smí.

Chování vzoru mění příznaky. re.IGNORECASE nerozlišuje velikost písmen, re.MULTILINE dá značkám ^ a $ význam začátku a konce každého řádku, re.DOTALL pustí tečku i přes konec řádku a re.VERBOSE dovolí psát vzor na více řádků s komentáři.

import re

html = "<b>tučně</b> a <i>kurzíva</i>"
print(re.findall(r"<.+>", html))
print(re.findall(r"<.+?>", html))
print(re.findall(r"<[^>]+>", html))

zaznam = "ERROR disk\ninfo start\nError síť"
print(re.findall(r"^error (\w+)", zaznam, re.IGNORECASE | re.MULTILINE))

CENA = re.compile(r"""
    (?P<castka> \d+ (?: [.,] \d{1,2} )? )   # celá část a případné haléře
    \s*
    (?P<mena> Kč | EUR )                    # měna
""", re.VERBOSE)

print(CENA.search("Celkem 149,50 Kč").groupdict())
Výstup
['<b>tučně</b> a <i>kurzíva</i>']
['<b>', '</b>', '<i>', '</i>']
['<b>', '</b>', '<i>', '</i>']
['disk', 'síť']
{'castka': '149,50', 'mena': 'Kč'}

re.compile uloží hotový vzor pod jménem. Hlavní přínos je čitelnost, protože běžné funkce modulu si vzory kešují i samy.

Regex je silný, a proto se snadno používá i tam, kam nepatří:

  • Pevný text vyřeší rychleji a čitelněji in, startswith, split nebo replace.
  • HTML čti parserem, viz BeautifulSoup. Vnořené značky regulárním výrazem spolehlivě nezvládneš.
  • JSON a CSV mají vlastní moduly, viz JSON a CSV.
  • Datum ověří strptime. Vzor \d{2}\.\d{2}\. s radostí přijme i 99.99..
  • E-mail zkontroluj zhruba (zavináč, tečka za ním) a skutečnou platnost ověř odesláním zprávy.
Kvíz

Který zápis správně ověří, že celý text jsou samé číslice?

Kvíz

Co vrátí re.findall(r"(a)b", "ab ab")?

Kvíz

Co najde <.+> v textu <a> <b>?

Pod kapotou · backtracking, ReDoS a unicode

Engine. Modul re je backtrackovací: zkouší varianty a při neúspěchu se vrací. Díky tomu umí zpětné reference a lookaround, ale v nejhorším případě trvá exponenciálně dlouho.

python
import re
re.fullmatch(r"(a+)+", "a" * 30 + "!")   # nespouštěj: prakticky se nedočkáš

Vnořený kvantifikátor dává exponenciálně mnoho způsobů, jak rozdělit a mezi vnitřní a vnější opakování, a koncové ! donutí engine vyzkoušet je všechny. Pokud takový vzor běží nad vstupem od uživatele, stačí jeden požadavek k zablokování procesu (ReDoS). re nemá timeout a GIL během shody neuvolňuje, takže stojí i ostatní vlákna.

Obrana: nevnořuj kvantifikátory nad překrývajícími se třídami, omez délku vstupu a používej konkrétní třídy místo .*. Od Pythonu 3.11 jsou k dispozici atomické skupiny (?>...) a posesivní kvantifikátory a++, které backtracking zakážou. Pro cizí vzory sáhni po enginu s lineární zárukou (google-re2), nebo po balíku regex, který umí timeout.

Unicode. U str je \d jakákoli desítková číslice Unicode, tedy i ٣, a int("٣") navíc projde. \w obsahuje písmena všech abeced. Na validaci strojových formátů dej re.ASCII nebo [0-9]. Jen písmena bez číslic a podtržítka popíše [^\W\d_]. re.IGNORECASE s Unicode umí překvapit: k se shoduje i se znakem Kelvina K.

Konec textu. $ se shoduje i před koncovým \n, takže re.match(r"\d+$", "123\n") projde. Přesný konec je \Z, nebo použij fullmatch. To je reálná díra ve validaci vstupů, které se později skládají do hlaviček nebo příkazů.

Lookaround testuje okolí, aniž by ho spotřeboval: (?=...), (?!...), (?<=...), (?<!...). Lookbehind musí mít v re pevnou délku. Třeba \d(?=(?:\d{3})+\b) najde číslice, za které patří oddělovač tisíců.

Výkon. Funkce na úrovni modulu kešují kompilované vzory, takže re.compile v cyklu moc nezrychlí. Pro hledání pevných řetězců jsou metody str řádově rychlejší. V Pythonu 3.13 se re.error přejmenoval na re.PatternError, staré jméno zůstává jako alias.

Vyzkoušej si: Zkoušečka regulárních výrazů

Piš vzor a text a sleduj zvýrazněné shody a skupiny. Používá regulární výrazy prohlížeče, které se od Pythonu v detailech liší.