Опережающие и ретроспективные проверки: lookahead и lookbehind

Восемь уроков назад вы искали в тексте цифры, слова и группы. Но у поиска всегда был один слепой угол: условие без захвата. Как найти слово, которое стоит перед двоеточием, но не тащить само двоеточие в результат? Как проверить, что после числа не идёт « руб», не отказываясь от поиска чисел? Как заставить одну регулярку проверить в пароле и строчную букву, и заглавную, и цифру — если каждая из них может стоять где угодно?

Для всего этого существуют проверки: опережающие и ретроспективные. Они не матчат символы, а задают условия позиции — в этом смысле они ближе к якорям ^ и \b из урока про якоря и границы слова, чем к обычным классам символов. Скобки тут тоже не группы: в отличие от скобок из урока про группы, захват не происходит. Сейчас разберём все четыре конструкции и соберём две задачи, которые без них решаются уродливо: пароль-валидация и разбиение чисел на разряды.

Что такое опережающая проверка (?=...) и почему она ничего не съедает?

Конструкция (?=...) читается так: «в этом месте дальше должен стоять текст, подходящий под образец, — но в совпадение он не входит». Опережающая проверка — это экзаменатор: он стоит в коридоре, смотрит, куда вы идёте, но сам в комнату не заходит. Посмотрим на разнице между тремя способами достать ключи конфига перед двоеточием.

import re

config = "host: pythonika.ru\nport: 443\ndebug: True"

print(re.findall(r"\w+(?=:)", config))
print(re.findall(r"\w+:", config))
print(re.search(r"\w+(?=:)", config).group())
print(re.search(r"\w+(?=:)", config).span())

['host', 'port', 'debug']
['host:', 'port:', 'debug:']
host
(0, 4)

Сравните первые две строки вывода. Шаблон \w+: захватил двоеточие в каждое совпадение — и вам пришлось бы отрезать его потом методом .rstrip(":"). Шаблон \w+(?=:) вернул чистые ключи. А span() расставляет точки над i: совпадение занимает позиции с 0 по 4, то есть ровно четыре символа слова host. Двоеточие стоит на позиции 4 — проверка до него дошла, но не включила.

Как проверить пароль несколькими условиями одной регуляркой?

Классика форм регистрации: пароль должен содержать строчную букву, заглавную и цифру, и быть не короче восьми символов. Проблема в том, что буквы могут стоять где угодно — «q1W2e3» и «Pass12» валидны, а порядок разный. Проверки решают элегантно: каждую ставим в начало строки, и все они оглядываются на весь текст с одной и той же позиции.

import re

PASSWORD = re.compile(r"(?=.*[a-z])(?=.*[A-Z])(?=.*\d)\S{8,}")

for pwd in ["qwerty", "Qwerty123", "QWERTY123", "Qwerty 123", "q1w2e3r4"]:
    print(pwd, "->", "ок" if PASSWORD.fullmatch(pwd) else "слабый")

qwerty -> слабый
Qwerty123 -> ок
QWERTY123 -> слабый
Qwerty 123 -> слабый
q1w2e3r4 -> слабый

Читаем шаблон по шагам. Движок встаёт в начало строки и сдаёт три экзамена подряд: (?=.*[a-z]) — «где-то дальше есть строчная буква», (?=.*[A-Z]) — «где-то есть заглавная», (?=\d) — точнее (?=.*\d) — «где-то есть цифра». Каждый экзамен сканирует строку вперёд и возвращается назад, не потратив ни одного символа. Только после трёх «принято» начинает работать \S{8,} — единственный кусок, который реально матчит текст целиком. fullmatch из урока про методы поиска гарантирует, что строка исчерпана. Тот же приём работает для любого набора требований: «есть буква и спецсимвол», «нет трёх одинаковых символов подряд» — каждое условие становится своей проверкой, и список растёт без запутанных вложенных if.

Когда нужно негативное опережение (?!...)?

Негативное опережение (?!...) переворачивает условие: «дальше НЕ должно быть текста по образцу». Задача: из строки с покупками достать все числа, кроме цен в рублях.

import re

text = "Чай 50 руб, кофе 120, сахар 200 рублей"

print(re.findall(r"\d+(?! руб)", text))

['5', '120', '20']

Что произошло? «50» испортилось в «5», «200» — в «20». Жадный \d+ сначала схватил всё число, проверка увидела « руб» и провалилась. Тогда включился возврат из урока про жадные и ленивые квантификаторы: \d+ отдал одну цифру назад, и проверка (?! руб) встала уже внутри числа — перед «0». Там условие «дальше нет руб» внезапно истинно, и движок счастлив: он нашёл «5» в середине пятидесяти.

import re

text = "Чай 50 руб, кофе 120, сахар 200 рублей"

print(re.findall(r"\b\d+\b(?! руб)", text))

['120']

Спасла граница слова \b. Теперь \d+ обязан начинаться и заканчиваться на границе, а между цифрами границ нет — отступить на цифру назад движок не может. Заметьте и вторую деталь: «200 рублей» тоже отсеялась, хотя это «рублей», а не «руб». Проверка смотрит ровно на следующие четыре символа, и « руб» там стоит. Для этой задачи это удача, но держите в голове: (?! руб) отсекает всё, что начинается с « руб».

Что делает ретроспективная проверка (?<=...)?

Ретроспективная проверка (?<=...) — зеркало опережающей: она смотрит не вперёд, а назад, и требует, чтобы перед позицией стоял текст по образцу. (?<=@)\w+ — «слово, слева от которого собака». Извлекаем домен из email, не захватывая собаку, и сравниваем со старым добрым способом через группу.

import re

mails = "Пишите на anna@pythonika.ru или boris@example.com"

print(re.findall(r"\w+(?=@)", mails))
print(re.findall(r"(?<=@)\w+", mails))
print(re.findall(r"@(\w+)", mails))

orders = "Заказ 42 отправлен, заказ 57 в сборке"
print(re.findall(r"(?<=заказ )\d+", orders))

['anna', 'boris']
['pythonika', 'example']
['pythonika', 'example']
['57']

Первые три способа дают одинаковые списки, но механизм разный: группа из третьей строки возвращает содержимое скобок, а проверка — всё совпадение целиком, просто короткое. Для findall это одно и то же, а вот в search разница выпрет наружу: у шаблона с проверкой .group() вернёт pythonika, у шаблона с группой — @pythonika, и домен живёт в .group(1). Практическое следствие: проверку стоит предпочесть группе, когда условие — про окружение, а не про сами данные, и вам не придётся потом отрезать лишний символ у каждого результата.

И заметьте: из двух заказов нашёлся только 57. «Заказ 42» написан с большой буквы, а шаблон требует строчное «заказ ». Как отменить чувствительность к регистру — тема следующего урока про флаги re.IGNORECASE и MULTILINE, а пока просто запомните: проверки смотрят на текст с точностью до символа.

Как работает негативная ретроспекция (?<!...)?

Негативная ретроспекция (?<!...) запрещает текст слева. Хороший пример — выбрать из финансовой сводки только положительные числа, не трогая убытки с минусом. Плюс разберём парные проверки на номерах версий: мажорная часть стоит перед точкой, минорная — после.

import re

release = "Python 3.12 и 3.11, Django 5.0, pip 24.2"

print(re.findall(r"\d+(?=\.)", release))
print(re.findall(r"(?<=\.)\d+", release))

money = "Прибыль 500, убыток -70, бонус 30"
print(re.findall(r"(?<!-)\b\d+", money))

['3', '3', '5', '24']
['12', '11', '0', '2']
['500', '30']

Первая пара: \d+(?=\.) оставила мажорные версии «3», «3», «5», «24» — точки не захватились; (?<=\.)\d+ — минорные. Негативная ретроспекция в третьей строке отработала хитро: у «-70» цифра «7» стоит сразу после минуса и отвергается, а движок, шагнув на «0», упирается в отсутствие границы слова — \b между «7» и «0» не пускает начаться новому совпадению. Снова та же мысль: проверки дружат с якорями.

Почему lookbehind в Python требует фиксированной ширины?

У ретроспективной проверки в Python есть жёсткое правило, которого нет у опережающей: образец внутри (?<=...) должен иметь заранее известную длину. Движку нужно встать на несколько символов назад, и он не готов угадывать, сколько именно. Попытка написать «после „руб“ или „рублей“» одной проверкой заканчивается ошибкой компиляции.

import re

re.compile(r"(?<=руб|рублей) \d+")

re.error: look-behind requires fixed-width pattern

Как превратить 1000000 в 1 000 000 одной заменой?

Задача-визитка проверок: расставить пробелы между разрядами числа. Формулировка условия красивая: «вставь пробел здесь, если слева цифра, а справа до конца числа — количество цифр, кратное трём». Без проверок такое выражают циклом с индексами и остатками; с ними — одной заменой.

import re

report = "Выручка 1000000, расходы 99000, прибыль 901000"

print(re.sub(r"(?<=\d)(?=(\d{3})+(?!\d))", " ", report))

Выручка 1 000 000, расходы 99 000, прибыль 901 000

Обе проверки нулевой длины, поэтому re.sub из урока про замену вставляет пробел между цифрами, не удаляя ничего. Идём по числу 1000000: после «1» справа шесть цифр — \d{3} срабатывает дважды, вставляем пробел; после «10» справа пять цифр — кратность не сошлась; после «100» — четыре; после «1000» — три, вставляем. Нюанс, на котором спотыкаются: соблазн заменить хвост (?!\d) якорем $ — и тогда число перед запятой перестаёт обрабатываться, потому что тройки упираются не в конец строки, а в знак препинания. Хвост (?!\d) гарантирует, что тройки дошли ровно до конца числа, а не до конца вселенной.

Что дальше

Вы научились ставить условия позициям: опережение, ретроспекция, их негативные версии — и применили их к паролю, ценам и разрядам чисел. В финале проверок есть мелкая заноза: «заказ» и «Заказ» для регулярки — разные слова. Чинится это флагами, и следующий урок — re.IGNORECASE, MULTILINE, DOTALL и VERBOSE — про них. Потом будет практикум по email, телефонам и датам, где проверки встречаются в каждом третьем шаблоне, а завершит раздел проект — парсер логов сервера.

Проверка не потребляет текст: она добавляет шаблону глаза, но не руки.