Методы re модуля

Модуль re предоставляет набор функций для работы с регулярными выражениями. Понимание каждого метода критично для эффективного использования regex.

#re.match() — поиск в начале строки

re.match() ищет совпадение только в начале строки:

import re

# Успешное совпадение в начале
re.match(r'Hello', 'Hello world')  # <re.Match object>

# Не найдёт, если паттерн не в начале
re.match(r'world', 'Hello world')  # None

# Эквивалентно паттерну с ^
re.match(r'pattern', string)  # То же, что re.search(r'^pattern', string)

#Возвращаемое значение

match = re.match(r'(\d+)', '123abc')
if match:
    match.group()    # '123' — полное совпадение
    match.groups()   # ('123',) — захваченные группы
    match.start()    # 0 — начало совпадения
    match.end()      # 3 — конец совпадения
    match.span()     # (0, 3) — кортеж (start, end)
else:
    print('No match')

#re.search() — поиск по всей строке

re.search() ищет первое совпадение в любом месте строки:

# Ищет по всей строке
re.search(r'world', 'Hello world')  # <re.Match object>

# Находит первое совпадение
re.search(r'\d+', 'abc123def456')  # '123' — первое число

#match() vs search()

# match() — только начало
re.match(r'\d+', 'abc123')  # None
re.match(r'\d+', '123abc')  # '123'

# search() — везде
re.search(r'\d+', 'abc123')  # '123'
re.search(r'\d+', '123abc')  # '123'

#re.findall() — все совпадения

re.findall() возвращает список всех совпадений:

# Без групп — список строк
re.findall(r'\d+', 'a1b23c456')  # ['1', '23', '456']

# С группами — список кортежей
re.findall(r'(\d+)-(\d+)', '1-2 3-4')  # [('1', '2'), ('3', '4')]

# С именованными группами — тоже кортежи
re.findall(r'(?P<a>\d+)-(?P<b>\d+)', '1-2')  # [('1', '2')]

#Пустые совпадения

# * можетсоответствует пустую строку
re.findall(r'a*', 'bbb')  # ['', '', '', ''] — 4 пустых совпадения

# Используйте + для непустых
re.findall(r'a+', 'bbb')  # []

#re.finditer() — итератор по совпадениям

re.finditer() возвращает итератор объектов Match:

text = 'abc123def456'

for match in re.finditer(r'\d+', text):
    print(f'{match.group()} at {match.span()}')
# 123 at (3, 6)
# 456 at (9, 12)

#Преимущества перед findall()

# findall() — создаёт весь список в памяти
matches = re.findall(r'\d+', large_text)

# finditer() — ленивая итерация, экономит память
for match in re.finditer(r'\d+', large_text):
    process(match.group())

#re.sub() — замена совпадений

re.sub() заменяет совпадения на строку или результат функции:

# Простая замена
re.sub(r'\d+', 'X', 'abc123def456')  # 'abcXdefX'

# Замена с backreferences
re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\3.\2.\1', '2024-03-09')
# '09.03.2024'

# С именованными группами
re.sub(r'(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})',
       r'\g<d>.\g<m>.\g<y>', '2024-03-09')

#Замена функцией

def upper_match(match):
    return match.group().upper()

re.sub(r'\w+', upper_match, 'hello world')  # 'HELLO WORLD'

# С группами
def swap_names(match):
    first, last = match.groups()
    return f'{last}, {first}'

re.sub(r'(\w+) (\w+)', swap_names, 'John Doe')  # 'Doe, John'

#Ограничение количества замен

# Заменить только первые 2 совпадения
re.sub(r'\d+', 'X', '1 2 3 4 5', count=2)  # 'X X 3 4 5'

#re.split() — разбиение строки

re.split() разбивает строку по паттерну:

# Разбиение по пробелам
re.split(r'\s+', 'one  two   three')  # ['one', 'two', 'three']

# Разбиение по нескольким разделителям
re.split(r'[,\s;]+', 'one, two; three  four')  # ['one', 'two', 'three', 'four']

# Разбиение по цифрам
re.split(r'\d+', 'abc123def456ghi')  # ['abc', 'def', 'ghi']

#Сохранение разделителей

# С захватывающей группой — разделители включаются
re.split(r'(\d+)', 'abc123def456')  # ['abc', '123', 'def', '456', 'ghi']

# С non-capturing группой — разделители не включаются
re.split(r'(?:\d+)', 'abc123def456')  # ['abc', 'def', 'ghi']

#Ограничение количества разбиений

# Максимум 2 разбиения
re.split(r'\s+', 'one two three four', maxsplit=2)  # ['one', 'two', 'three four']

#re.compile() — компиляция паттерна

re.compile() создаёт объект Pattern для повторного использования:

# Компиляция
pattern = re.compile(r'\d+')

# Использование
pattern.search('abc123')  # <re.Match object>
pattern.findall('a1b23c456')  # ['1', '23', '456']
pattern.sub('X', 'abc123def')  # 'abcXdef'

#Преимущества компиляции

# Без компиляции — компиляция при каждом вызове
for text in texts:
    re.search(r'\d+', text)

# С компиляцией — компиляция один раз
pattern = re.compile(r'\d+')
for text in texts:
    pattern.search(text)

#Флаги при компиляции

pattern = re.compile(r'hello', re.IGNORECASE | re.MULTILINE)

pattern.search('HELLO')  # Найдёт
pattern.search('hello')  # Найдёт

#Методы объекта Match

Объект Match, возвращаемый match(), search(), finditer(), имеет методы:

match = re.search(r'(\d+)-(\d+)', '123-456')

match.group()      # '123-456' — полное совпадение
match.group(0)     # '123-456' — то же
match.group(1)     # '123' — первая группа
match.group(2)     # '456' — вторая группа
match.groups()     # ('123', '456') — все группы

match.groupdict()  # {} — словарь именованных групп

match.start()      # 0 — начало совпадения
match.end()        # 7 — конец совпадения
match.span()       # (0, 7) — (start, end)

match.re           # Скомпилированный паттерн
match.string       # Исходная строка

#Именованные группы

match = re.search(r'(?P<a>\d+)-(?P<b>\d+)', '123-456')

match.group('a')      # '123'
match.group('b')      # '456'
match.groupdict()     # {'a': '123', 'b': '456'}

#Практические примеры

#1. Валидация email

def is_valid_email(email):
    pattern = r'^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

is_valid_email('user@example.com')  # True
is_valid_email('invalid')           # False

#2. Извлечение всех ссылок из HTML

def extract_links(html):
    pattern = r'<a\s+href="([^"]+)">'
    return re.findall(pattern, html)

extract_links('<a href="url1">Link1</a><a href="url2">Link2</a>')
# ['url1', 'url2']

#3. Нормализация пробелов

def normalize_spaces(text):
    return re.sub(r'\s+', ' ', text.strip())

normalize_spaces('  hello   world  ')  # 'hello world'

#4. Парсинг логов

def parse_log_line(line):
    pattern = r'(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (?P<level>\w+) (?P<message>.+)'
    match = re.match(pattern, line)
    if match:
        return match.groupdict()
    return None

parse_log_line('2024-03-09 14:30:15 ERROR Database connection failed')
# {'timestamp': '2024-03-09 14:30:15', 'level': 'ERROR', 'message': 'Database connection failed'}

#Распространённые ошибки

#1. match() вместо search()

# Ошибка: match() ищет только в начале
re.match(r'\d+', 'abc123')  # None

# Правильно: search() ищет везде
re.search(r'\d+', 'abc123')  # '123'

#2. Проверка на None

# Ошибка: вызов group() на None
match = re.match(r'\d+', 'abc')
match.group()  # AttributeError

# Правильно: проверка на None
match = re.match(r'\d+', 'abc')
if match:
    print(match.group())

#3. findall() с группами

# Ошибка: ожидали полные совпадения
re.findall(r'(\d+)-(\d+)', '1-2 3-4')  # [('1', '2'), ('3', '4')]

# Правильно: non-capturing группы
re.findall(r'(?:\d+)-(?:\d+)', '1-2 3-4')  # ['1-2', '3-4']