Регулярные выражения на практике

Поиск одного совпадения – это search. Когда нужно не первое, а все, берут другую функцию.

re.findall(шаблон, строка) – возвращает список всех совпадений, найденных в строке слева направо. Не объекты Match, а готовые куски текста.

Разница в возврате не случайна. search рассказывает всё о одном совпадении: где оно стоит, из чего состоит. findall отвечает на другой вопрос – «что тут вообще есть», – и потому отдаёт только текст, без координат и без объектов.

import re

text = 'В корзине 12 яблок, 5 груш и 2026 вишен.'

print(re.findall(r'\d+', text))        # ['12', '5', '2026']
print(len(re.findall(r'\d+', text)))   # 3 – столько чисел

print(re.findall(r'\d+', 'здесь чисел нет'))   # []
# пустой список, а не None: совпадений не нашлось ни одного

Список удобно считать: len() даёт количество совпадений. Именно так в задаче про журнал и узнаётся, сколько строк подошло.

Первое, на чём спотыкаются все: стоит в шаблоне появиться скобкам, и findall возвращает совсем не то, что от него ждут.

import re

text = 'кот 3, пёс 12'

print(re.findall(r'\w+ \d+', text))
# ['кот 3', 'пёс 12'] – совпадения целиком

print(re.findall(r'(\w+) \d+', text))
# ['кот', 'пёс'] – только содержимое группы

print(re.findall(r'(\w+) (\d+)', text))
# [('кот', '3'), ('пёс', '12')] – кортежи групп

Правило ровно такое: без групп – совпадения целиком, одна группа – список её содержимого, две и больше – список кортежей. И сделано это нарочно. Скобки в шаблоне ставят не просто так, а чтобы выделить нужную часть, – и findall возвращает именно её. Числа из примера нужны были без слов, и лишний текст в списке только мешал бы.

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

print(re.findall(r'((\w+) (\d+))', text))
# [('кот 3', 'кот', '3'), ('пёс 12', 'пёс', '12')]

И предупреждение на будущее: круглые скобки в шаблоне – это всегда группа. Поставленные просто чтобы сгруппировать ветки «или», они точно так же переменят результат findall. Для такой группировки есть форма (?:…) – скобки без памяти:

print(re.findall(r'(?:кот|пёс)', 'кот и пёс'))
# ['кот', 'пёс'] – строки, а не кортежи

Второй способ разобрать найденное на части – группы. Он работает и с search, и с match, и с fullmatch.

Группа – часть шаблона в круглых скобках. Совпадение с этой частью запоминается отдельно, и его можно достать из объекта Match.

import re

m = re.search(r'(\d{2})\.(\d{2})\.(\d{4})', '03.09.2026')

print(m.group(0))     # 03.09.2026 – всё совпадение
print(m.group(1))     # 03 – первая группа
print(m.group(2))     # 09
print(m.group(3))     # 2026
print(m.groups())     # ('03', '09', '2026')

group(0) – это всё совпадение целиком, а группы начинаются с единицы. Номер группы определяется открывающей скобкой: первая слева открылась – первая группа, вторая открылась – вторая. Поэтому вложенные одна в другую скобки нумеруются по порядку открытия:

m = re.search(r'((\d{2})\.(\d{2})\.(\d{4}))', '03.09.2026')

print(m.group(1))     # 03.09.2026 – внешняя скобка
print(m.group(2))     # 03 – та, что открылась следом

Работает это только с объектом Match: findall объектов не отдаёт, у него вместо group() – список, разобранный в предыдущем блоке.

replace() из урока 8.2 меняет один точно известный кусок. Когда заменять надо по образцу – все числа, все даты, все пробелы подряд, – берут re.sub.

re.sub(шаблон, замена, строка) – заменяет все совпадения шаблона на указанный текст и возвращает новую строку.

import re

print(re.sub(r'\d', '*', 'кот 3 и пёс 12'))
# кот * и пёс **

Четвёртый параметр – count – ограничивает число замен. count=1 заменит только первое совпадение, count=3 – первые три; без него заменяются все:

print(re.sub(r'\d', '*', 'кот 3 и пёс 12', count=1))
# кот * и пёс 12

Замена на пустую строку – это удаление: так убирают лишние пробелы, дефисы или знаки препинания. А ещё запомним главное: исходная строка не меняется. sub ничего не правит на месте – он возвращает новую строку, и если результат никуда не сохранить, всё останется как было. Строки в Python неизменяемы (урок 8.1), заменить в них символ невозможно в принципе.

split() из урока 8.2 умеет одну из двух вещей: без аргумента режет по пробелам, с аргументом – по одной точно известной строке. Несколько разных разделителей ему недоступны, а в данных они встречаются постоянно: поля пишут то через точку с запятой, то через запятую, то через точку.

re.split(шаблон, строка) – разрезает строку по всем местам, которые подходят под шаблон. Разделителем может быть любой образец, а не только одна конкретная строка.

Чаще всего разделители просто перечисляют в классе:

import re

line = 'Иванов;9А,5.отлично'
print(re.split(r'[;,.]', line))
# ['Иванов', '9А', '5', 'отлично']

Связка из урока 8.2 сделала бы то же самое только цепочкой replace: сначала один знак заменить на общий, потом второй, потом резать. При трёх-четырёх разделителях такая цепочка становится нечитаемой, а ошибка в порядке замен тихо портит данные.

Шаблон умеет и то, чего split() не умеет вовсе, – описать разделитель вместе с окружением. Так снимают разделители вместе с пробелами вокруг них, и отдельный strip() потом не нужен:

line = 'Иванов ; 9А , 5'
print(re.split(r'\s*[,;]\s*', line))   # ['Иванов', '9А', '5']

И привычка, которую стоит завести сразу: подряд идущие разделители дают пустые куски. Разрез строки 'Иванов;;9А' по шаблону [,;] даст три элемента, и средний из них – пустая строка: между двумя разделителями ничего не было. Это не поломка, а сведения. Если пустые куски не нужны, их отбрасывают вручную – так и сделано в примере ниже.

Теперь соединим регулярные выражения с файлами из урока 8.4. Схема всегда одна и та же: открыть файл, пройти по строкам циклом, на каждой строке найти образец и сложить найденное в накопитель.

import re

total = 0
with open('journal.txt', encoding='utf-8') as f:
    for line in f:
        for number in re.findall(r'\d+', line):
            total += int(number)

Накопитель – обычная переменная, объявленная до цикла. Внутри цикла она меняется, а после него хранит итог; если объявить её внутри, на каждой строке счёт начинался бы заново.

И подробность про перевод строки. Строка, прочитанная из файла, приходит с \n на конце (урок 8.4), и это почти никогда не мешает: \d+ ищет цифры, а перевод строки – не цифра. Полезно и обратное: точка . по умолчанию перевод строки не находит, поэтому шаблон .+ не выйдет за пределы своей строки и не склеит две записи в одну. А вот $ прямо перед этим \n совпадение заканчивает – так и находят число в самом конце строки.

Регулярное выражение – инструмент мощный, и именно поэтому его хочется применить везде. Делать так не стоит.

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

Разница не только в длине записи. Проверка 'да' in line – прямое сравнение подстроки, а re.search разбирает шаблон и проходит по строке по правилам движка; на тысячах строк это заметная разница в скорости. И читается in без всякой подготовки: чтобы понять re.search(r'да', line), надо помнить, как устроены шаблоны.

Регулярка нужна там, где перечислить варианты нельзя, а образец описать можно: дата, номер телефона, почтовый индекс, все числа в файле. Там она незаменима. Там, где текст известен заранее, она лишняя.