Регулярные выражения в Python: модуль re, паттерны, группы и замены

Когда тянуться к regex

Регулярные выражения - маленький язык для описания текстовых паттернов. Они мощные и легко над-используются.

Прежде чем идти к re, спроси себя, справятся ли обычные методы строк. .split(), .replace(), .startswith(), "target" in text - быстрее, читаемее и менее подвержены ошибкам, чем эквивалентный regex. Оставь regex для случаев, где нужный тебе паттерн действительно структурированный, но слишком гибкий для фиксированных строковых операций: email-ы, номера телефонов, лог-строки с известной формой, HTML или Markdown куски, любой поиск «найди такое-то вот».

Базовый словарь

Regex-паттерн - строка, описывающая то, что ты ищешь. Несколько кирпичиков:

• . - любой один символ
• \d - любая цифра (0–9)
• \w - любой «словесный» символ (буква, цифра, подчёркивание)
• \s - любой пробельный символ
• ^ - начало строки
• $ - конец строки
• [abc] - один из a, b или c
• [^abc] - любой символ, кроме a, b, c
• a|b - a или b
• * - ноль или больше предыдущего
• + - один или больше
• ? - ноль или один
• {3} - ровно 3
• {2,5} - от 2 до 5
• ( ... ) - группа (захватывает совпадение внутри)

Этого хватит на большинство реальных regex-ов.

Ключевые функции

re.search(pattern, text) находит первое совпадение где угодно в строке. Возвращает match-объект или 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")

Всегда используй raw-строку (r"...") для regex-паттернов. Иначе Python попытается интерпретировать обратные слэши как строковые escape-ы, и ты получишь другой паттерн, чем задумывал.

re.match(pattern, text) как search, но совпадает только в начале:

import re

print(re.search(r"hello", "say hello"))   # match
print(re.match(r"hello", "say hello"))    # None - didn't start with hello

Чаще всего нужен search.

re.findall(pattern, text) возвращает все неперекрывающиеся совпадения списком:

import re

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

Заметь: findall возвращает строки, а не match-объекты. Если в паттерне одна группа - получишь содержимое группы. Несколько групп - список кортежей.

Захватывающие группы

Скобки в паттерне захватывают то, что совпало внутри:

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))  # the whole match
    print(match.group(1))  # '2026' - first group
    print(match.group(2))  # '04'
    print(match.group(3))  # '20'
    print(match.group(4))  # 'server started'
    print(match.groups())  # tuple of all groups

Именованные группы обычно читаются лучше:

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())

Как только в regex больше одной группы, имена делают код извлечения значительно понятнее.

Замена через re.sub

re.sub(pattern, replacement, text) заменяет каждое совпадение:

import re

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

Вырезает всё, что не цифра. В замене можно ссылаться на захваченные группы через \1, \2 и так далее, а в raw-строках \g<1> яснее:

import re

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

В качестве замены можно передать и функцию. Удобно для преобразований, не сводящихся к простому обмену:

import re

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

Компилируем паттерн для переиспользования

Если ты используешь один и тот же паттерн много раз - особенно в цикле, - скомпилируй его один раз:

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())

У скомпилированных паттернов те же методы - search, match, findall, sub - только без паттерна первым аргументом. Чуть эффективнее и часто читаемее.

Флаги

Типичные модификаторы, передаваемые аргументом flags= или соединяемые через |:

• re.IGNORECASE (re.I) - без учёта регистра.
• re.MULTILINE (re.M) - ^ и $ совпадают на каждой строке, а не только на границах всей строки.
• re.DOTALL (re.S) - . совпадает и с переводом строки (по умолчанию - нет).
• re.VERBOSE (re.X) - разрешает пробелы и #-комментарии в паттерне ради читаемости.

import re

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

re.VERBOSE особенно удобен для сложных паттернов:

import re

pattern = re.compile(r"""
    (?P<user>[\w.]+)    # username part
    @                    # literal at sign
    (?P<domain>[\w.-]+)  # domain
""", re.VERBOSE)

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

Многострочные закомментированные regex-ы поддерживать гораздо проще, чем непрозрачные однострочники.

Жадные vs ленивые

Квантификаторы (*, +, ?, {n,}) по умолчанию жадные - хватают как можно больше. Добавь ?, чтобы сделать их ленивыми:

import re

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

# Greedy - matches from the first < to the last >
print(re.findall(r"<.+>", html))

# Lazy - matches each tag separately
print(re.findall(r"<.+?>", html))

Жадная версия захватывает всю подстроку от <b> до </i> - скорее всего, не то, чего ты хотел. Ленивый .+? останавливается на первом >.

(Заметка на полях: реальный HTML regex-ом в продакшене не парсят. Используй html.parser или BeautifulSoup. Пример выше - только ради демонстрации жадности.)

Реалистичный пример

Разбор строк простого лога:

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())

Много мощности в немногих строках.

Несколько привычек

• Всегда используй raw-строки для паттернов.
• Начинай с простейшего работающего паттерна; ужесточай потом.
• Именованные группы - как только групп больше одной.
• Компилируй паттерны, которые будешь переиспользовать.
• Regex медленнее обычных методов строк. Если .split() справится - бери .split().

Дальше: ошибки и отладка

Это закрывает тур по реальным данным - файлам, JSON, CSV, HTTP, датам и regex. В любой реальной программе рано или поздно всплывает ошибка, и умение хорошо читать трейсбэки Python - самый большой отладочный навык, который можно развить. Последняя глава - про исключения и конкретные ошибки, которые встречаются чаще всего.