re — Операции с регулярными выражениями

Синтаксис регулярных выражений

Регулярное выражение (или RE) задаёт множество строк, которые ему соответствуют; функции в этом модуле позволяют проверить, соответствует ли определённая строка заданному регулярному выражению (или если заданное регулярное выражение соответствует определённой строке, что сводится к тому же самому).

Регулярные выражения можно конкатенировать, чтобы сформировать новые регулярные выражения; если A и B — оба регулярные выражения, то AB также является регулярным выражением. В общем случае, если строка p соответствует A, а другая строка q соответствует B, то строка pq будет соответствовать AB. Это верно, если A или B не содержат операций с низким приоритетом; граничные условия между A и B; или имеют ссылки на группы с номерами. Таким образом, сложные выражения легко можно построить из более простых основных выражений, описанных здесь. Для получения подробной информации о теории и реализации регулярных выражений обратитесь к книге Фридла [Frie09] или почти любой учебной книге по построению компиляторов.

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

Регулярные выражения могут содержать как специальные, так и обычные символы. Большинство обычных символов, таких как 'A', 'a', или '0', являются простейшими регулярными выражениями; они просто соответствуют самим себе. Вы можете конкатенировать обычные символы, поэтому last соответствует строке 'last'. (В остальной части этого раздела мы будем писать RE в this special style, обычно без кавычек, а строки, которые нужно сопоставить, 'in single quotes'.)

Некоторые символы, такие как '|' или '(', являются специальными. Специальные символы либо обозначают классы обычных символов, либо влияют на то, как интерпретируются окружающие их регулярные выражения.

Операторы повторения или квантификаторы (*, +, ?, {m,n}, и т.д.) не могут быть непосредственно вложены. Это предотвращает неоднозначность с суффиксом модификатора нежадного соответствия ?, и с другими модификаторами в других реализациях. Для применения второго повторения к внутреннему повторению могут использоваться скобки. Например, выражение (?:a{6})* соответствует любому кратному шести 'a' символам.

Специальные символы:

.

(Точка.) В стандартном режиме это соответствует любому символу, кроме новой строки. Если указан флаг DOTALL, это соответствует любому символу, включая новую строку. (?s:.) соответствует любому символу независимо от флагов.

^

(Знак возведения в степень.) Соответствует началу строки, а в режиме MULTILINE также соответствует сразу после каждой новой строки.

$

Соответствует концу строки или непосредственно перед новой строкой в конце строки, а в режиме MULTILINE также соответствует перед новой строкой. foo соответствует как ‘foo’, так и ‘foobar’, в то время как регулярное выражение foo$ соответствует только ‘foo’. Более интересно, поиск foo.$ в 'foo1\nfoo2\n' соответствует ‘foo2’ в обычном режиме, а ‘foo1’ в режиме MULTILINE; поиск одного $ в 'foo\n' найдёт два (пустых) соответствия: одно непосредственно перед новой строкой и одно в конце строки.

*

Заставляет результирующее RE соответствовать 0 или более повторений предшествующего RE, как можно больше повторений. ab* будет соответствовать ‘a’, ‘ab’ или ‘a’, после которого следует любое количество ‘b’.

+

Заставляет результирующее RE соответствовать 1 или более повторений предшествующего RE. ab+ будет соответствовать ‘a’, после которого следует любое ненулевое количество ‘b’s; оно не будет соответствовать только ‘a’.

?

Заставляет результирующее RE соответствовать 0 или 1 повторению предшествующего RE. ab? будет соответствовать либо ‘a’, либо ‘ab’.

*?, +?, ??

Квантификаторы '*', '+', и '?' являются жадными; они соответствуют как можно большему количеству текста. Иногда такое поведение нежелательно; если RE <.*> сопоставляется со строкой '<a> b <c>', оно будет соответствовать всей строке, а не только '<a>'. Добавление ? после квантификатора заставляет его выполнять соответствие в нежадном или минимальном режиме; будет соответствовать как можно меньше символов. Используя RE <.*?> будет соответствовать только '<a>'.

*+, ++, ?+

Подобно квантификаторам '*', '+', и '?', те, где '+' добавлен, также соответствуют как можно большему количеству раз. Однако, в отличие от истинных жадных квантификаторов, они не допускают обратной проверки, когда выражение, следующее за ним, не может быть сопоставлено. Эти известны как поглощающие квантификаторы. Например, a*a будет соответствовать 'aaaa', потому что a* будет соответствовать всем 4 'a's, но, когда встречается конечный 'a', выражение перепроверяется, так что в итоге a* соответствует 3 'a's всего, и четвёртый 'a' соответствует конечному 'a'. Однако, когда a*+a используется для соответствия 'aaaa', a*+ будет соответствовать всем 4 'a', но когда конечный 'a' не сможет найти больше символов для соответствия, выражение не может быть перепроверено и, следовательно, не сможет соответствовать. x*+, x++ и x?+ эквивалентны (?>x*), (?>x+) и (?>x?) соответственно.

Добавлен в версии 3.11.

{m}

Указывает, что должно быть сопоставлено ровно m копий предыдущего RE; меньше соответствий приводят к тому, что все RE не соответствуют. Например, a{6} будет соответствовать ровно шести 'a' символам, но не пяти.

{m,n}

Заставляет результирующее RE соответствовать от m до n повторений предшествующего RE, пытаясь сопоставить как можно больше повторений. Например, a{3,5} будет соответствовать от 3 до 5 'a' символов. Пропуск m указывает нижнюю границу 0, а пропуск n указывает бесконечную верхнюю границу. В качестве примера, a{4,}b будет соответствовать 'aaaab' или тысяче 'a' символам, после которых следует 'b', но не 'aaab'. Запятую нельзя опустить, иначе модификатор будет смешиваться с ранее описанной формой.

{m,n}?

Заставляет результирующее RE соответствовать от m до n повторений предшествующего RE, пытаясь сопоставить как можно меньше повторений. Это нежадная версия предыдущего квантификатора. Например, в строке из 6 символов 'aaaaaa', a{3,5} будет соответствовать 5 'a' символам, тогда как a{3,5}? будет соответствовать только 3 символам.

{m,n}+

Заставляет результирующее RE соответствовать от m до n повторений предшествующего RE, пытаясь сопоставить как можно больше повторений, не создавая никаких точек обратной проверки. Это поглощающая версия вышеуказанного квантификатора. Например, в строке из 6 символов 'aaaaaa', a{3,5}+aa пытается сопоставить 5 'a' символов, затем, требуя ещё 2 'a's, потребует больше символов, чем доступно, и, следовательно, потерпит неудачу, в то время как a{3,5}aa будет соответствовать a{3,5} захватит 5, затем 4 'a's путём обратной проверки, а затем конечные 2 'a's будут соответствовать конечному aa в шаблоне. x{m,n}+ эквивалентно (?>x{m,n}).

Добавлен в версии 3.11.

\

Либо экранирует специальные символы (позволяя вам сопоставить символы, такие как '*', '?', и так далее), либо сигнализирует о специальной последовательности; специальные последовательности обсуждаются ниже.

Если вы не используете строку ссылок для выражения шаблона, помните, что Python также использует обратную косую черту в качестве последовательности экранирования в строковых литералах; если последовательность экранирования не распознаётся анализатором Python, обратная косая черта и последующий символ включаются в результирующую строку. Однако, если Python распознает полученную последовательность, обратная косая черта должна быть повторена дважды. Это сложно и трудно понять, поэтому настоятельно рекомендуется использовать строки ссылок для всех, кроме самых простых выражений.

[]

Используется для указания набора символов. В наборе:

• Символы могут быть перечислены индивидуально, например [amk] будет соответствовать 'a', 'm', или 'k'.

• Диапазоны символов могут быть указаны, задав два символа и разделив их '-', например [a-z] будет соответствовать любой строчной букве ASCII, [0-5][0-9] будет соответствовать всем двузначным числам от 00 до 59, а [0-9A-Fa-f] будет соответствовать любой шестнадцатеричной цифре. Если - экранирована (например, [a\-z]) или если она размещена в качестве первого или последнего символа (например, [-a] или [a-] ), она будет соответствовать буквальному '-'.
• Специальные символы теряют свой специальный смысл внутри наборов. Например, [(+*)] будет соответствовать любому из буквальных символов '(', '+', '*', или ')'.

• Классы символов, такие как \w или \S (определены ниже), также принимаются внутри набора, хотя символы, которым они соответствуют, зависят от используемых флагов.

• Символам, которые не входят в диапазон, можно соответствовать, дополняя набор. Если первый символ набора — '^', всем символам, которые не входят в набор, будет соответствовать. Например, [^5] будет соответствовать любому символу, кроме '5', а [^^] будет соответствовать любому символу, кроме '^'. ^ не имеет специального значения, если это не первый символ в наборе.
• Для соответствия буквальному ']' внутри набора нужно предварять его обратной косой чертой или помещать его в начало набора. Например, оба [()[\]{}] и []()[{}] будут соответствовать правой скобке, а также левой скобке, фигурным скобкам и круглым скобкам.

• Поддержка вложенных наборов и операций над наборами, как в Unicode Technical Standard #18, может быть добавлена в будущем. Это изменит синтаксис, поэтому для облегчения этой смены в неоднозначных случаях будет подниматься FutureWarning. Это включает наборы, начинающиеся с буквального '[' или содержащие буквальные последовательности символов '--', '&&', '~~', и '||'. Чтобы избежать предупреждения, экранируйте их обратной косой чертой.

Изменено в версии 3.7: FutureWarning поднимается, если набор символов содержит конструкции, которые изменят семантику в будущем.

|

A|B, где A и B могут быть произвольными регулярными выражениями, создаёт регулярное выражение, которое будет соответствовать либо A, либо B. Произвольное количество регулярных выражений может быть разделено '|' таким образом. Это также может быть использовано внутри групп (см. ниже). При сканировании целевой строки регулярные выражения, разделённые '|', пытаются соответствовать слева направо. Когда один шаблон полностью соответствует, эта ветвь принимается. Это означает, что как только A соответствует, B больше не будет тестироваться, даже если бы это привело к более длинному соответствию в целом. Другими словами, оператор '|' никогда не является жадным. Для соответствия буквальному '|' используйте \|, или заключите его в набор символов, как в [|].

(...)

Соответствует любому регулярному выражению, которое находится внутри круглых скобок, и указывает начало и конец группы; содержимое группы может быть получено после выполнения соответствия и может быть сопоставлено позже в строке с помощью \number специальной последовательности, описанной ниже. Для соответствия буквальным '(' или ')' используйте \( или \), или заключите их в набор символов: [(], [)].

(?...)

Это обозначение расширения (a '?' после '(' не имеет смысла иначе). Первый символ после '?' определяет смысл и дальнейший синтаксис конструкции. Расширения обычно не создают новую группу; (?P<name>...) — единственное исключение из этого правила. Ниже приведены текущие поддерживаемые расширения.

(?aiLmsux)

(Одна или несколько букв из набора 'a', 'i', 'L', 'm', 's', 'u', 'x'.) Группа соответствует пустой строке; буквы устанавливают соответствующие флаги для всего регулярного выражения:

• re.A (только соответствие ASCII)
• re.I (без учёта регистра)
• re.L (зависимо от локали)
• re.M (многострочное)
• re.S (точка соответствует всем)
• re.U (соответствие Unicode)
• re.X (развёрнутый)

(Флаги описаны в Содержимое модуля.) Это полезно, если вы хотите включить флаги как часть регулярного выражения вместо передачи аргумента флага функции re.compile(). Флаги должны использоваться вначале в строке выражения.

Изменено в версии 3.11: Это конструкция может быть использована только в начале выражения.

(?:...)

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

(?aiLmsux-imsx:...)

(Ноль или более букв из набора 'a', 'i', 'L', 'm', 's', 'u', 'x', необязательно после '-' за которым следует одна или несколько букв из набора 'i', 'm', 's', 'x'.) Буквы устанавливают или снимают соответствующие флаги для части выражения:

• re.A (только соответствие ASCII)
• re.I (без учёта регистра)
• re.L (зависимо от локали)
• re.M (многострочное)
• re.S (точка соответствует всем)
• re.U (соответствие Unicode)
• re.X (развёрнутый)

(Флаги описаны в Содержимое модуля.)

Буквы 'a', 'L' и 'u' взаимно исключают друг друга при использовании в качестве флагов в строке, поэтому их нельзя объединять или следовать за '-'. Вместо этого, когда один из них появляется в строке, он переопределяет режим соответствия во включающей группе. В Unicode-шаблонах (?a:...) переключается на соответствие только ASCII, а (?u:...) переключается на соответствие Unicode (по умолчанию). В шаблонах байтов (?L:...) переключается на соответствие, зависящее от локали, а (?a:...) переключается на соответствие только ASCII (по умолчанию). Это переопределение действует только для узкой строки, а исходный режим соответствия восстанавливается за пределами строки.

Добавлена в версии 3.6.

Изменено в версии 3.7: Буквы 'a', 'L' и 'u' также могут быть использованы в группе.

(?>...)

Пытается сопоставить ... как если бы это было отдельное регулярное выражение, а при успехе продолжает сопоставлять остальную часть шаблона после него. Если последующий шаблон не соответствует, стек может быть восстановлен только до точки до (?>...), потому что после выхода выражение, известное как атомная группа, отбрасывает все точки стека внутри себя. Таким образом, (?>.*). никогда не будет соответствовать чему-либо, потому что сначала .* будет соответствовать всем возможным символам, а затем, не имея ничего оставшегося для соответствия, окончательное . не сможет сопоставиться. Поскольку в атомной группе нет сохранённых точек стека и нет точки стека до неё, всё выражение не будет соответствовать.

Добавлена в версии 3.11.

(?P<name>...)

Аналогично обычным круглым скобкам, но подстрока, соответствующая группе, доступна через символическое имя группы name. Имена групп должны быть допустимыми идентификаторами Python, а в шаблонах bytes они могут содержать только байты в диапазоне ASCII. Каждое имя группы должно быть определено только один раз в регулярном выражении. Символическая группа также является пронумерованной группой, как если бы группа не имела имени.

Именованные группы могут быть использованы в трёх контекстах. Если шаблон (?P<quote>['"]).*?(?P=quote) (т. е. соответствует строке, заключённой в одинарные или двойные кавычки):

Контекст ссылки на группу “quote”	Способы ссылки на неё
в самом шаблоне	(?P=quote) (как показано) \1
при обработке объекта совпадения m	m.group('quote') m.end('quote') (и т. д.)
в строке, переданной в аргумент repl функции re.sub()	\g<quote> \g<1> \1

Изменено в версии 3.12: В шаблонах bytes имя группы name может содержать только байты в диапазоне ASCII (b'\x00'-b'\x7f').

(?P=name)

Ссылка на именованную группу; она соответствует той же текстовой последовательности, что и ранее соответствующая группа с именем name.

(?#...)

Комментарий; содержимое скобок просто игнорируется.

(?=...)

Соответствует, если ... соответствует дальше, но не потребляет никакой части строки. Это называется утверждением предвосхищения. Например, Isaac (?=Asimov) будет соответствовать 'Isaac ' только в том случае, если за ним следует 'Asimov'.

(?!...)

Соответствует, если ... не соответствует дальше. Это утверждение отрицательного предвосхищения. Например, Isaac (?!Asimov) будет соответствовать 'Isaac ' только в том случае, если за ним не следует 'Asimov'.

(?<=...)

Соответствует, если текущее положение в строке предшествует совпадению с ..., которое заканчивается в текущем положении. Это называется утверждением положительного обратного просмотра. (?<=abc)def найдёт совпадение в 'abcdef', так как обратный просмотр вернётся на 3 символа назад и проверит, соответствует ли содержащийся шаблон. Содержащийся шаблон должен соответствовать строкам фиксированной длины, что означает, что abc или a|b допустимы, но a* и a{3,4} — нет. Обратите внимание, что шаблоны, которые начинаются с утверждений положительного обратного просмотра, не будут соответствовать началу искомой строки; вы, скорее всего, захотите использовать функцию search(), а не функцию match():

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

Этот пример ищет слово, следующее за дефисом:

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

Изменено в версии 3.5: Добавлена поддержка ссылок на группы фиксированной длины.

(?<!...)

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

(?(id/name)yes-pattern|no-pattern)

Попытается сопоставить с yes-pattern , если группа с заданным id или name существует, и с no-pattern , если нет. no-pattern необязательно и может быть опущено. Например, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) — плохой шаблон для поиска электронных писем, который будет соответствовать '<user@host.com>' и 'user@host.com', но не '<user@host.com' ни 'user@host.com>'.

Изменено в версии 3.12: Группа id может содержать только ASCII цифры. В шаблонах bytes имя группы name может содержать только байты в диапазоне ASCII (b'\x00'-b'\x7f').

Специальные последовательности состоят из '\' и символа из следующего списка. Если обычный символ не является ASCII цифрой или ASCII буквой, то результирующее регулярное выражение будет соответствовать второму символу. Например, \$ соответствует символу '$'.

\number

Соответствует содержимому группы с тем же номером. Группы нумеруются, начиная с 1. Например, (.+) \1 соответствует 'the the' или '55 55', но не 'thethe' (обратите внимание на пробел после группы). Эта специальная последовательность может использоваться только для соответствия одной из первых 99 групп. Если первая цифра number равна 0 или number имеет длину 3 восьмеричных цифр, она не будет интерпретироваться как совпадение с группой, а как символ с восьмеричным значением number. Внутри '[' и ']' класса символов все числовые экранирования рассматриваются как символы.

\A

Соответствует только в начале строки.

\b

Соответствует пустой строке, но только в начале или конце слова. Слово определяется как последовательность символов слова. Обратите внимание, что формально \b определяется как граница между \w и \W символом (или наоборот), или между \w и началом или концом строки. Это означает, что r'\bat\b' соответствует 'at', 'at.', '(at)', и 'as at ay' но не 'attempt' или 'atlas'.

По умолчанию символами слова в шаблонах Unicode (str) являются Unicode буквенно-цифровые символы и символ подчёркивания, но это можно изменить, используя флаг ASCII. Границы слов определяются текущим языковым стандартом, если используется флаг LOCALE.

Примечание

Внутри диапазона символов \b представляет символ ввода, для совместимости с строковыми литералами Python.

\B

Соответствует пустой строке, но только тогда, когда она не находится в начале или конце слова. Это означает, что r'at\B' соответствует 'athens', 'atom', 'attorney', но не 'at', 'at.', или 'at!'. \B — противоположность \b, поэтому символы слова в шаблонах Unicode (str) — Unicode буквенно-цифровые символы или символ подчёркивания, хотя это можно изменить с помощью флага ASCII. Границы слов определяются текущим языковым стандартом, если используется флаг LOCALE.

Примечание

Обратите внимание, что \B не соответствует пустой строке, что отличается от реализаций регулярных выражений в других языках программирования, таких как Perl. Это поведение сохраняется для совместимости.

\d

Для шаблонов Unicode (str):

Соответствует любой десятичной цифре Unicode (то есть любому символу в категории символов Unicode [Nd]). Это включает [0-9], а также многие другие цифры.

Соответствует [0-9] при использовании флага ASCII.

Для шаблонов 8-битных (bytes):

Соответствует любой десятичной цифре в наборе символов ASCII; это эквивалентно [0-9].

\D

Соответствует любому символу, который не является десятичной цифрой. Это противоположность \d.

Соответствует [^0-9] при использовании флага ASCII.

\s

Для шаблонов Unicode (str):

Соответствует Unicode символам пробела (как определено функцией str.isspace()). Это включает [ \t\n\r\f\v], а также многие другие символы, например, неразрывные пробелы, предписанные правилами типографики во многих языках.

Соответствует [ \t\n\r\f\v] при использовании флага ASCII.

Для шаблонов 8-битных (bytes):

Соответствует символам, считающимся пробелами в наборе символов ASCII; это эквивалентно [ \t\n\r\f\v].

\S

Соответствует любому символу, который не является символом пробела. Это противоположность \s.

Соответствует [^ \t\n\r\f\v] при использовании флага ASCII.

\w

Для шаблонов Unicode (str):

Совпадает с символами Unicode-слов; это включает все Unicode-буквенно-цифровые символы (как определено в str.isalnum()), а также символ подчёркивания (_).

Совпадает с [a-zA-Z0-9_] при использовании флага ASCII.

Для шаблонов 8-битных (bytes):

Совпадает с символами, считающимися буквенно-цифровыми в наборе символов ASCII; это эквивалентно [a-zA-Z0-9_]. Если используется флаг LOCALE, совпадают символы, считающиеся буквенно-цифровыми в текущем языковом стандарте, и символ подчёркивания.

\W

Совпадает с любым символом, который не является символом слова. Это противоположность \w. По умолчанию совпадают символы, не являющиеся подчёркиваниями (_), для которых str.isalnum() возвращает False.

Совпадает с [^a-zA-Z0-9_] при использовании флага ASCII.

Если используется флаг LOCALE, совпадают символы, которые не являются буквенно-цифровыми в текущем языковом стандарте, и символом подчёркивания.

\Z

Совпадает только в конце строки.

Большинство последовательностей экранирования, поддерживаемых строками Python, также принимаются парсером регулярных выражений:

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\

(Обратите внимание, что \b используется для представления границ слов и означает «ввод» только внутри символьных классов.)

'\u', '\U', и '\N' последовательности экранирования распознаются только в шаблонах Unicode (str). В шаблонах bytes они являются ошибками. Неизвестные ASCII-символьные последовательности экранирования зарезервированы для будущего использования и обрабатываются как ошибки.

Восьмеричные последовательности экранирования включаются в ограниченной форме. Если первая цифра равна 0, или если есть три восьмеричные цифры, она считается восьмеричной последовательностью экранирования. В противном случае это ссылка на группу. Как и для строковых литералов, восьмеричные последовательности экранирования всегда имеют длину не более трех цифр.

Содержание модуля

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

Объекты регулярных выражений

class re.Pattern

Объект скомпилированного регулярного выражения, возвращаемый методом re.compile().

Изменено в версии 3.9: re.Pattern поддерживает [] для указания шаблона Unicode (str) или байтов. См. Тип обобщённого псевдонима.

Pattern.search(string[, pos[, endpos]])

Ищет в строке string первое вхождение шаблона регулярного выражения и возвращает соответствующий объект Match. Возвращает None , если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от нахождения совпадения нулевой длины в какой-то точке строки.

Необязательный второй параметр pos задаёт индекс в строке, с которого должно начинаться поиск; по умолчанию он равен 0. Это не полностью эквивалентно срезу строки; символ шаблона '^' соответствует началу строки и позициям сразу после символа новой строки, но не обязательно позиции, с которой начинается поиск.

Необязательный параметр endpos ограничивает область поиска; как будто строка имеет длину endpos символов, так что будут проверятся только символы от pos до endpos - 1. Если endpos меньше pos, совпадение не будет найдено. В противном случае, если rx — это объект скомпилированного регулярного выражения, rx.search(string, 0, 50) эквивалентно rx.search(string[:50], 0).

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

Pattern.match(string[, pos[, endpos]])

Если нуль или более символов в начале строки string соответствуют этому регулярному выражению, возвращает соответствующий объект Match. Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Необязательные параметры pos и endpos имеют то же значение, что и для метода search().

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>

Если требуется найти соответствие где-либо в string, используйте search() (см. также search() против match()).

Pattern.fullmatch(string[, pos[, endpos]])

Если вся строка string соответствует этому регулярному выражению, возвращает соответствующий объект Match. Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Необязательные параметры pos и endpos имеют то же значение, что и для метода search().

>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.fullmatch("ogre")     # No match as not the full string matches.
>>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>

Добавлена в версии 3.4.

Pattern.split(string, maxsplit=0)

Идентично функции split(), использующей скомпилированный шаблон.

Pattern.findall(string[, pos[, endpos]])

Аналогично функции findall(), использующей скомпилированный шаблон, но также принимает необязательные параметры pos и endpos, которые ограничивают область поиска, как для search().

Pattern.finditer(string[, pos[, endpos]])

Аналогично функции finditer(), использующей скомпилированный шаблон, но также принимает необязательные параметры pos и endpos, которые ограничивают область поиска, как для search().

Pattern.sub(repl, string, count=0)

Идентично функции sub(), использующей скомпилированный шаблон.

Pattern.subn(repl, string, count=0)

Идентично функции subn(), использующей скомпилированный шаблон.

Pattern.flags

Флаги соответствия регулярного выражения. Это комбинация флагов, заданных compile(), любых флагов в шаблоне, и неявных флагов, таких как UNICODE, если шаблон — строка Unicode.

Pattern.groups

Количество захватывающих групп в шаблоне.

Pattern.groupindex

Словарь, сопоставляющий любые символические имена групп, определённые (?P<id>) , с номерами групп. Словарь пуст, если в шаблоне не было символических групп.

Pattern.pattern

Строка шаблона, из которой был скомпилирован объект шаблона.

Объекты совпадений

Объекты совпадений всегда имеют булевое значение True. Поскольку match() и search() возвращают None при отсутствии совпадения, вы можете проверить, было ли совпадение, с помощью простого оператора if:

match = re.search(pattern, string)
if match:
    process(match)

class re.Match

Объект совпадения, возвращаемый успешными match и search.

Изменено в версии 3.9: re.Match поддерживает [] для указания совпадения с Unicode (str) или байтами. См. Тип обобщённого псевдонима.

Match.expand(template)

Возвращает строку, полученную путём подстановки обратных слэшей в шаблонную строку template, как это делает метод sub(). Экранированные последовательности, такие как \n преобразуются в соответствующие символы, а числовые обратные ссылки (\1, \2) и именованные обратные ссылки (\g<1>, \g<name>) заменяются содержимым соответствующей группы. Обратная ссылка \g<0> будет заменена на всё совпадение.

Изменено в версии 3.5: Несовпавшие группы заменяются пустой строкой.

Match.group([group1, ...])

Возвращает одну или несколько подгрупп совпадения. Если есть один аргумент, результат — одна строка; если есть несколько аргументов, результат — кортеж с одним элементом на каждый аргумент. Без аргументов group1 по умолчанию равен нулю (возвращается всё совпадение). Если аргумент groupN равен нулю, соответствующее возвращаемое значение — вся строка совпадения; если он находится в диапазоне [1..99], это строка, соответствующая соответствующей скобочной группе. Если номер группы отрицательный или больше, чем количество групп, определённых в шаблоне, генерируется исключение IndexError. Если группа содержится в части шаблона, которая не сошлась, соответствующее значение — None. Если группа содержится в части шаблона, которая совпала несколько раз, возвращается последнее совпадение.

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # The entire match
'Isaac Newton'
>>> m.group(1)       # The first parenthesized subgroup.
'Isaac'
>>> m.group(2)       # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2)    # Multiple arguments give us a tuple.
('Isaac', 'Newton')

Если регулярное выражение использует синтаксис (?P<name>...), аргументы groupN также могут быть строками, идентифицирующими группы по их имени. Если строковый аргумент не используется как имя группы в шаблоне, генерируется исключение IndexError.

Умеренно сложный пример:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

Именованные группы также можно ссылаться по их индексу:

>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'

Если группа совпадает несколько раз, доступна только последняя:

>>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
>>> m.group(1)                        # Returns only the last match.
'c3'

Match.__getitem__(g)

Это идентично m.group(g). Это позволяет проще получить доступ к отдельной группе из совпадения:

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0]       # The entire match
'Isaac Newton'
>>> m[1]       # The first parenthesized subgroup.
'Isaac'
>>> m[2]       # The second parenthesized subgroup.
'Newton'

Поддерживаются также именованные группы:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Isaac Newton")
>>> m['first_name']
'Isaac'
>>> m['last_name']
'Newton'

Добавлен в версии 3.6.

Match.groups(default=None)

Возвращает кортеж, содержащий все подгруппы совпадения, начиная с 1 до числа групп в шаблоне. Аргумент default используется для групп, не участвовавших в совпадении; по умолчанию он равен None.

Например:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

Если мы сделаем десятичную точку и всё после неё необязательным, не все группы могут участвовать в совпадении. Эти группы будут по умолчанию None, если аргумент default не задан:

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Second group defaults to None.
('24', None)
>>> m.groups('0')   # Now, the second group defaults to '0'.
('24', '0')

Match.groupdict(default=None)

Возвращает словарь, содержащий все именованные подгруппы совпадения, с ключами, являющимися именами подгрупп. Аргумент default используется для групп, не участвовавших в совпадении; по умолчанию он равен None. Например:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

Match.start([group])

Match.end([group])

Возвращает индексы начала и конца подстроки, соответствующей group; group по умолчанию равен нулю (т.е. вся сопоставленная подстрока). Возвращает -1 если group существует, но не повлияла на совпадение. Для объекта совпадения m и группы g, которая повлияла на совпадение, подстрока, сопоставленная с группой g (эквивалентна m.group(g)) равна

m.string[m.start(g):m.end(g)]

Обратите внимание, что m.start(group) будет равно m.end(group) если group сопоставилась с пустой строкой. Например, после m = re.search('b(c?)', 'cba'), m.start(0) равно 1, m.end(0) равно 2, m.start(1) и m.end(1) оба равны 2, а m.start(2) вызывает исключение IndexError.

Пример удаления remove_this из адресов электронной почты:

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'

Match.span([group])

Для совпадения m возвращает 2-кортеж (m.start(group), m.end(group)). Обратите внимание, что если group не повлияла на совпадение, это (-1, -1). group по умолчанию равен нулю, всё совпадение.

Match.pos

Значение pos, переданное методам search() или match() объекта объекта регулярного выражения. Это индекс в строке, с которого движок RE начал поиск совпадения.

Match.endpos

Значение endpos, переданное методам search() или match() объекта объекта регулярного выражения. Это индекс в строке, за которым движок RE не пойдёт.

Match.lastindex

Целочисленный индекс последней сопоставленной захватывающей группы или None если ни одна группа не сопоставлена. Например, выражения (a)b, ((a)(b)), и ((ab)) будут иметь lastindex == 1 при применении к строке 'ab', тогда как выражение (a)(b) будет иметь lastindex == 2, если применён к той же строке.

Match.lastgroup

Имя последней сопоставленной захватывающей группы или None если у группы нет имени или если ни одна группа не сопоставлена.

Match.re

Объект регулярного выражения, метод match() или search() которого произвёл этот экземпляр совпадения.

Match.string

Строка, переданная методам match() или search().

Примеры регулярных выражений

def displaymatch(match):
    if match is None:
        return None
    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q"))  # Valid.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Invalid.
>>> displaymatch(valid.match("akt"))    # Invalid.
>>> displaymatch(valid.match("727ak"))  # Valid.
"<Match: '727ak', groups=()>"

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Pair of 7s.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # No pairs.
>>> displaymatch(pair.match("354aa"))     # Pair of aces.
"<Match: '354aa', groups=('a',)>"

>>> pair = re.compile(r".*(.).*\1")
>>> pair.match("717ak").group(1)
'7'

# Error because re.match() returns None, which doesn't have a group() method:
>>> pair.match("718ak").group(1)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    re.match(r".*(.).*\1", "718ak").group(1)
AttributeError: 'NoneType' object has no attribute 'group'

>>> pair.match("354aa").group(1)
'a'

/usr/sbin/sendmail - 0 errors, 4 warnings

%s - %d errors, %d warnings

(\S+) - (\d+) errors, (\d+) warnings

>>> re.match("c", "abcdef")    # No match
>>> re.search("c", "abcdef")   # Match
<re.Match object; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Match
<re.Match object; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") # No match

>>> re.match("c", "abcdef")    # No match
>>> re.search("^c", "abcdef")  # No match
>>> re.search("^a", "abcdef")  # Match
<re.Match object; span=(0, 1), match='a'>

>>> re.match("X", "A\nB\nX", re.MULTILINE)  # No match
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Match
<re.Match object; span=(4, 5), match='X'>

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""

>>> entries = re.split("\n+", text)
>>> entries
['Ross McFluff: 834.345.1254 155 Elm Street',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']

>>> [re.split(":? ", entry, maxsplit=3) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

>>> [re.split(":? ", entry, maxsplit=4) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

>>> def repl(m):
...     inner_word = list(m.group(2))
...     random.shuffle(inner_word)
...     return m.group(1) + "".join(inner_word) + m.group(3)
...
>>> text = "Professor Abdolmalek, please report your absences promptly."
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly\b", text)
['carefully', 'quickly']

>>> text = "He was carefully disguised but captured quickly by police."
>>> for m in re.finditer(r"\w+ly\b", text):
...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: carefully
40-47: quickly

>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>

>>> re.match(r"\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('ASSIGN',   r':='),           # Assignment operator
        ('END',      r';'),            # Statement terminator
        ('ID',       r'[A-Za-z]+'),    # Identifiers
        ('OP',       r'[+\-*/]'),      # Arithmetic operators
        ('NEWLINE',  r'\n'),           # Line endings
        ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
        ('MISMATCH', r'.'),            # Any other character
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

Token(type='IF', value='IF', line=2, column=4)
Token(type='ID', value='quantity', line=2, column=7)
Token(type='THEN', value='THEN', line=2, column=16)
Token(type='ID', value='total', line=3, column=8)
Token(type='ASSIGN', value=':=', line=3, column=14)
Token(type='ID', value='total', line=3, column=17)
Token(type='OP', value='+', line=3, column=23)
Token(type='ID', value='price', line=3, column=25)
Token(type='OP', value='*', line=3, column=31)
Token(type='ID', value='quantity', line=3, column=33)
Token(type='END', value=';', line=3, column=41)
Token(type='ID', value='tax', line=4, column=8)
Token(type='ASSIGN', value=':=', line=4, column=12)
Token(type='ID', value='price', line=4, column=15)
Token(type='OP', value='*', line=4, column=21)
Token(type='NUMBER', value=0.05, line=4, column=23)
Token(type='END', value=';', line=4, column=27)
Token(type='ENDIF', value='ENDIF', line=5, column=4)
Token(type='END', value=';', line=5, column=9)