Регулярные выражения: язык шаблонов

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

Дальше будет много незнакомых знаков, но пугаться нечего: весь язык шаблонов – два десятка символов. Выучить их проще, чем два десятка методов строки, и работают они по похожим правилам в любом языке программирования. Каждый знак-правило называют метасимволом.

Работают с шаблонами через модуль re – он из стандартной библиотеки, и ставить ничего не надо (про модули – урок 8.5):

import re

Приставка re в названиях функций – сокращение от regular expression, «регулярное выражение».

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

Сырая строка – строковый литерал с буквой r перед кавычкой. В нём обратный слэш остаётся самим собой: Python не превращает его ни в служебный символ, ни в начало служебной последовательности.

Дело в том, что обратный слэш в обычной строке – начало команды. '\n' – это не два знака, а один: перевод строки. '\t' – табуляция, '\b' – забой, тот самый, которым затирают символ (клавиша Backspace). Все эти последовательности Python заменяет ещё когда читает текст программы.

Беда в том, что в шаблоне обратный слэш – тоже команда, только своя. \d значит «цифра», \b – «граница слова». И это ровно те же два знака. Какую из двух команд выполнит Python?

Свою. Замену делает не re, а сам язык, и делает раньше: в строке '\d' последовательность \d остаётся на месте (Python её не знает, оставляет как есть и в новых версиях ещё и предупреждает), а вот '\b' – уже нет: там получится один невидимый символ забоя, и шаблон станет другим. Именно так ломается самый частый шаблон новичка: записанный как '\bкот\b' вместо r'\bкот\b', он перестаёт находить слово «кот» – потому что ищет забой, слово и снова забой.

Лечится это буквой r:

print(len('\b'))    # 1 – один служебный символ
print(len(r'\b'))   # 2 – обратный слэш и буква b, как и надо

Правило простое: шаблон всегда пишут сырой строкой. r'\d+', r'\bкот\b', r'\d{2}\.\d{2}\.\d{4}'. Привыкнуть к букве r легко, а искать потом, почему шаблон «почти работает», – долго.

Самые нужные метасимволы описывают один символ – но не какой-то конкретный, а любой из целой группы.

Запомнить пары легко: большая буква отрицает маленькую. \d – цифра, \D – всё, кроме цифры. Так устроены все три пары.

И отдельно про \w – то, чего не ожидают. В большинстве языков \w значит строго [A-Za-z0-9_]: латинские буквы, цифры и подчёркивание. В Python это иначе: \w считает буквой любую букву Юникода, и кириллица входит в неё целиком. re.findall(r'\w+', 'кот и котлета') вернёт ['кот', 'и', 'котлета']. Это удобно: один и тот же шаблон годится и для английского текста, и для русского.

Про re.findall стоит сказать сразу: она возвращает все совпадения списком. Это удобно, когда надо посмотреть, что шаблон вообще находит, – именно её строку показывает виджет в этом уроке. А три главные функции поиска – search, match и fullmatch – разберём в конце.

Метасимволы описывают группы, заведённые заранее. Свой набор собирают в классе – квадратных скобках:

Три подробности, на которых спотыкаются.

Внутри класса точка – это точка. [.] значит ровно точку, а не «любой символ»: внутри скобок метасимволы теряют силу. Поэтому точку в дате можно искать и как [.], и как \. – получится одно и то же.

Диапазон идёт от меньшего к большему. [а-я] работает, [я-а] – нет: Python отказывается собирать такой шаблон и сообщает об ошибке. Порядок символов в диапазоне – не пожелание, а правило.

Крышка отрицает весь класс целиком. [^0-9] – один символ, не цифра. Сочетать «не» с частью списка нельзя: [^абв] читается как «любой, кроме а, б и в», и никак иначе.

И главное: класс – это всегда один символ, сколько бы в нём ни было перечислено. Чтобы таких символов шло подряд несколько, нужны квантификаторы – о них через блок.

Метасимвол описывает один символ, а сколько таких символов идёт подряд – говорит квантификатор, то есть «сколько раз». Он ставится сразу после символа и относится ровно к нему:

Звёздочка и плюс различаются одним: * разрешает символу не быть вовсе, + требует хотя бы один. Отсюда разница: шаблон ab*c найдёт ac, а ab+c – нет.

Вопросительный знак значит «может быть, а может и не быть». Именно им описывают необязательный знак: -?\d+ – «минус, если он есть, и число после».

И ловушка, которую создаёт {n}. Квантификатор считает символы, а не числа: для шаблона \d{3} в строке 6789 есть ровно три цифры подряд – это 678, а оставшаяся девятка никого не волнует. Шаблон не проверяет, что число трёхзначное; он ищет три цифры подряд, а где они стоят – не его дело.

Квантификаторы * и + жадные: они берут как можно больше символов. Отсюда неожиданный результат, на котором спотыкаются даже опытные:

import re

text = 'Кавычки: "раз" и "два"'

print(re.search(r'".*"', text).group())    # "раз" и "два"
print(re.search(r'".*?"', text).group())   # "раз"

Первый шаблон ищет кавычку, потом что угодно, потом кавычку – и находит от первой кавычки до последней: .* забрал и «раз», и второе открытие кавычки, и всё между ними. Второй отличается одним знаком – вопросительным после звёздочки – и берёт минимум: от кавычки до ближайшей следующей кавычки.

Жадный квантификатор – берёт как можно больше символов. Добавленный после него ? делает квантификатор ленивым: берёт как можно меньше.

Запомнить, какой из двух что делает, помогает сама запись: ? рядом с квантификатором читается как «не надо много, хватит и меньшего».

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

Пока все шаблоны искали совпадение где угодно в строке. Но иногда нужно, чтобы кусок стоял в определённом месте – в начале или в конце.

^ и $ – не символы, а места. Они ничего не занимают в строке и ничего не добавляют к совпадению: шаблон ^\d+ в строке 12 34 найдёт 12, а не «начало» вместе с 12. Это называют нулевой шириной: проверка есть, а текста за ней нет.

Из этого следует полезное. ^\d+ требует цифры в начале, но ничего не говорит про остаток строки. Чтобы потребовать ещё и конец, ставят $: шаблон ^\d+$ подойдёт строке 12, но не строке 12 34.

\b – граница слова. Это тоже место, а не символ: оно стоит там, где с одной стороны буква, цифра или подчёркивание, а с другой – ничего такого. Записывают границу, когда слово нужно найти целиком: r'\bкот\b' найдёт кот в строке кот и котлета, но котлета ему не подойдёт – там после кот идёт буква, а не граница. Без \b шаблон кот нашёл бы кусок слова и в котлете тоже.

Часть знаков в шаблоне значит не себя, а правило: . * + ? { } [ ] ^ $ и сам \. Все они уже встретились выше.

Отсюда вопрос: как искать точку, если . значит «любой символ»? Ответ – поставить перед ней обратный слэш:

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

Это ровно та причина, из-за которой дату ищут шаблоном r'\d{2}\.\d{2}\.\d{4}', а не r'\d{2}.\d{2}.\d{4}'. Второй шаблон формально тоже сработает – но он найдёт и 03x09y2026: точки в нём значат «любой символ». Ошибка, которая проходит все проверки на правильных данных и ломается на первой же случайной строке.

Внутри класса символов экранировать почти нечего: там, как уже сказано, [.] и так значит точку. А вот обратный слэш экранируют всегда, и в шаблоне он записывается двумя знаками: \\ – это один знак \ в готовой строке.

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

Все три возвращают одно и то же: либо объект Match – найденный кусок со всеми сведениями о нём, либо None – «ничего не нашлось».

None – особое значение «здесь ничего нет». Оно не равно ни пустой строке, ни нулю: так функция честно сообщает, что результата не получилось.

Проверяют результат всегда одинаково, через if:

m = re.search(шаблон, строка)
if m:
    print(m.group())     # есть совпадение – вот его текст
else:
    print('не найдено')

if m: читается как «если совпадение есть»: объект Match в условии даёт истину, а None – ложь. Текст самого совпадения забирают методом m.group().

Самая частая ошибка – пропустить проверку:

print(re.search(r'X', 'кот').group())
# AttributeError: 'NoneType' object has no attribute 'group'

Сообщение читается странно, а означает простое: совпадения не нашлось, None – это не Match, и метода group() у него нет. Поэтому перед group() всегда стоит if m:.

Одна таблица на весь урок – синтаксис и функции вместе.

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