Regex w Pythonie: moduł re, wzorce, grupy i zamiana

Kiedy sięgać po regex

Wyrażenia regularne to mały język do opisywania wzorców tekstu. Są potężne i łatwo ich nadużywać.

Zanim sięgniesz po re, zastanów się, czy nie wystarczą zwykłe metody napisów. .split(), .replace(), .startswith(), "target" in text są szybsze, czytelniejsze i mniej podatne na błędy niż odpowiedni regex. Regex zostaw na sytuacje, gdy wzorzec, na którym ci zależy, jest naprawdę uporządkowany, ale zbyt elastyczny dla stałych operacji na napisach: adresy e-mail, numery telefonów, linie logów o znanym kształcie, fragmenty HTML albo Markdown, każde wyszukiwanie typu "znajdź coś takiego".

Podstawowe słownictwo

Wzorzec regex to napis opisujący, czego szukasz. Kilka elementów składowych:

• .: dowolny pojedynczy znak
• \d: dowolna cyfra (od 0 do 9)
• \w: dowolny znak "słowa" (litera, cyfra, podkreślnik)
• \s: dowolny biały znak
• ^: początek napisu
• $: koniec napisu
• [abc]: jeden ze znaków a, b lub c
• [^abc]: dowolny znak oprócz a, b, c
• a|b: a lub b
• *: zero lub więcej wystąpień poprzedniego elementu
• +: jedno lub więcej
• ?: zero lub jedno
• {3}: dokładnie 3
• {2,5}: od 2 do 5
• ( ... ): grupa (przechwytuje dopasowanie w środku)

To wystarczy do większości wyrażeń regularnych w praktyce.

Najważniejsze funkcje

re.search(pattern, text) znajduje pierwsze dopasowanie w dowolnym miejscu napisu. Zwraca obiekt dopasowania albo None:

import re

text = "Order 12345 shipped on 2026-04-20"
match = re.search(r"\d{5}", text)

if match:
    print("Found:", match.group())
    print("Position:", match.start(), "-", match.end())
else:
    print("No match")

Wzorce regex zawsze zapisuj jako surowe napisy (r"..."). W przeciwnym razie Python spróbuje zinterpretować ukośniki wsteczne jako sekwencje ucieczki i dostaniesz inny wzorzec niż ten, który widać w kodzie.

re.match(pattern, text) działa jak search, ale dopasowuje tylko na początku:

import re

print(re.search(r"hello", "say hello"))   # dopasowanie
print(re.match(r"hello", "say hello"))    # None: napis nie zaczynał się od hello

Zwykle chodzi ci o search.

re.findall(pattern, text) zwraca wszystkie nienachodzące na siebie dopasowania jako listę:

import re

text = "Apples 3, oranges 12, pears 7"
numbers = re.findall(r"\d+", text)
print(numbers)   # ['3', '12', '7']

Zauważ, że findall zwraca napisy, a nie obiekty dopasowania. Jeśli wzorzec ma jedną grupę, dostajesz z powrotem zawartość grupy. Przy kilku grupach dostajesz listę krotek.

Grupy przechwytujące

Nawiasy we wzorcu przechwytują to, co dopasowało się w ich wnętrzu:

import re

line = "2026-04-20: server started"
match = re.search(r"(\d{4})-(\d{2})-(\d{2}): (.+)", line)

if match:
    print(match.group(0))  # całe dopasowanie
    print(match.group(1))  # '2026': pierwsza grupa
    print(match.group(2))  # '04'
    print(match.group(3))  # '20'
    print(match.group(4))  # 'server started'
    print(match.groups())  # krotka wszystkich grup

Grupy nazwane są zwykle czytelniejsze:

import re

line = "2026-04-20: server started"
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}): (?P<msg>.+)"
match = re.search(pattern, line)

if match:
    print(match["year"], match["month"], match["day"])
    print(match.groupdict())

Gdy regex ma więcej niż jedną grupę, nadanie im nazw sprawia, że kod wyciągający dane jest dużo łatwiejszy do śledzenia.

Zamiana przez re.sub

re.sub(pattern, replacement, text) zamienia każde dopasowanie:

import re

text = "Call me at (415) 555-1234 or 212.555.5678"
cleaned = re.sub(r"[^\d]", "", text)
print(cleaned)

To usuwa wszystko, co nie jest cyfrą. Zamiennik może odwoływać się do przechwyconych grup przez \1, \2 itd., a w surowych napisach czytelniejsze jest \g<1>:

import re

text = "Alice Johnson, Bob Smith, Carol Tran"
swapped = re.sub(r"(\w+) (\w+)", r"\2, \1", text)
print(swapped)

Jako zamiennik możesz też przekazać funkcję. Przydaje się to przy przekształceniach, które nie są prostą zamianą:

import re

text = "Prices: 10, 20, 30"
doubled = re.sub(r"\d+", lambda m: str(int(m.group()) * 2), text)
print(doubled)

Kompilowanie wzorców do ponownego użycia

Jeśli używasz tego samego wzorca wiele razy, zwłaszcza w pętli, skompiluj go raz:

import re

DATE = re.compile(r"\d{4}-\d{2}-\d{2}")

lines = [
    "started at 2026-04-20",
    "no timestamp here",
    "finished 2026-04-21",
]

for line in lines:
    match = DATE.search(line)
    if match:
        print(match.group())

Skompilowane wzorce udostępniają te same metody (search, match, findall, sub), tylko bez wzorca jako pierwszego argumentu. Są nieco wydajniejsze i często czytelniejsze.

Flagi

Typowe modyfikatory, przekazywane jako argument flags= albo łączone operatorem OR:

• re.IGNORECASE (re.I): dopasowanie bez rozróżniania wielkości liter.
• re.MULTILINE (re.M): ^ i $ dopasowują się na początku i końcu każdej linii, a nie tylko na granicach napisu.
• re.DOTALL (re.S): . dopasowuje też znaki nowej linii (domyślnie tego nie robi).
• re.VERBOSE (re.X): pozwala na białe znaki i komentarze # we wzorcu, dla czytelności.

import re

text = "HELLO world"
print(re.search(r"hello", text))
print(re.search(r"hello", text, re.IGNORECASE))

re.VERBOSE jest szczególnie przydatne przy złożonych wzorcach:

import re

pattern = re.compile(r"""
    (?P<user>[\w.]+)    # część z nazwą użytkownika
    @                    # dosłowny znak małpy
    (?P<domain>[\w.-]+)  # domena
""", re.VERBOSE)

match = pattern.search("Contact me at rosa@example.com")
if match:
    print(match.groupdict())

Wieloliniowe, skomentowane wyrażenia regularne są nieporównanie łatwiejsze w utrzymaniu niż nieprzejrzyste jednolinijkowce.

Zachłanne kontra leniwe

Kwantyfikatory (*, +, ?, {n,}) są domyślnie zachłanne: dopasowują tyle, ile się da. Dodaj ?, żeby stały się leniwe:

import re

html = "<b>bold</b> and <i>italic</i>"

# Zachłanne: dopasowuje od pierwszego < do ostatniego >
print(re.findall(r"<.+>", html))

# Leniwe: dopasowuje każdy tag osobno
print(re.findall(r"<.+?>", html))

Wersja zachłanna przechwytuje cały fragment od <b> do </i>, co prawdopodobnie nie jest tym, o co ci chodziło. Leniwe .+? zatrzymuje się na pierwszym >.

(Na marginesie: w produkcji nie parsuj HTML wyrażeniami regularnymi. Użyj html.parser albo BeautifulSoup. Powyższy przykład służy tylko zilustrowaniu zachłanności.)

Realistyczny przykład

Parsowanie linii z prostego formatu logów:

import re

log = """
2026-04-20 09:00:12 INFO  Server started
2026-04-20 09:01:45 WARN  Slow query detected
2026-04-20 09:03:01 ERROR Database connection lost
"""

pattern = re.compile(r"""
    (?P<date>\d{4}-\d{2}-\d{2})\s+
    (?P<time>\d{2}:\d{2}:\d{2})\s+
    (?P<level>INFO|WARN|ERROR)\s+
    (?P<message>.+)
""", re.VERBOSE)

for line in log.strip().splitlines():
    match = pattern.match(line)
    if match:
        print(match.groupdict())

Mnóstwo możliwości w niewielu liniach.

Kilka nawyków

• Wzorce zawsze zapisuj jako surowe napisy.
• Zacznij od najprostszego działającego wzorca; zawężaj później.
• Używaj grup nazwanych, gdy masz więcej niż jedną grupę.
• Kompiluj wzorce, których użyjesz wielokrotnie.
• Regex jest wolniejszy od zwykłych metod napisów. Jeśli wystarczy .split(), użyj .split().

Dalej: błędy i debugowanie

To zamyka przegląd pracy z prawdziwymi danymi: pliki, JSON, CSV, HTTP, daty i regex. Jednak każdy prawdziwy program prędzej czy później trafia na błąd, a sprawne czytanie tracebacków Pythona to najważniejsza umiejętność debugowania, jaką możesz zdobyć. Ostatni rozdział omawia wyjątki i konkretne błędy, które spotkasz najczęściej.