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

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

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

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

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

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

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

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

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

.

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

^

(Каретка.) Совпадает с началом строки, а в режиме 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“; не будет соответствовать только „a“.

?

Приводит к тому, что результирующий RE будет соответствовать 0 или 1 повторению предыдущего RE. ab? будет соответствовать либо „a“, либо „ab“.

*?, +?, ??

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

{m}

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

{m,n}

Заставляет результирующий RE соответствовать от m до n повторений предыдущего RE, стараясь соответствовать как можно большему количеству повторений. Например, a{3,5} будет соответствовать от 3 до 5 символов 'a'. Если опустить m, то нижняя граница будет равна нулю, а если опустить 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 символам.

\

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

Если вы не используете необработанную строку для выражения шаблона, помните, что 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 (определение дано ниже), также принимаются внутри набора, хотя символы, которым они соответствуют, зависят от того, действует ли режим ASCII или LOCALE.

• Символы, не входящие в диапазон, могут быть сопоставлены с помощью complementing набора. Если первым символом набора является '^', то будут сопоставлены все символы, которые не входят в набор. Например, [^5] будет соответствовать любой символ, кроме '5', а [^^] будет соответствовать любой символ, кроме '^'. ^ не имеет специального значения, если это не первый символ в наборе.

• Для соответствия литералу ']' внутри набора, предварите его обратной косой чертой или поместите в начало набора. Например, и [()[\]{}], и []()[{}] будут соответствовать скобке.

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

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

|

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

(...)

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

(?...)

Это расширительная нотация ('?', следующий за '(', не имеет смысла). Первый символ после '?' определяет значение и дальнейший синтаксис конструкции. Расширения обычно не создают новую группу; (?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 (многословный), для всего регулярного выражения. (Флаги описаны в Содержание модуля.) Это удобно, если вы хотите включить флаги как часть регулярного выражения, вместо того, чтобы передавать аргумент flag функции re.compile(). Флаги должны использоваться первыми в строке выражения.

(?:...)

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

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

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

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

(?P<name>...)

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

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

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

(?P=name)

Обратная ссылка на именованную группу; она соответствует тексту, которому соответствовала предыдущая группа с именем name.

(?#...)

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

(?=...)

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

(?!...)

Совпадает, если ... не совпадает со следующим. Это negative lookahead assertion. Например, Isaac (?!Asimov) будет соответствовать 'Isaac ' только если за ним не следует 'Asimov'.

(?<=...)

Устанавливает соответствие, если текущей позиции в строке предшествует соответствие для ..., которое заканчивается на текущей позиции. Это называется positive lookbehind assertion. (?<=abc)def найдет совпадение в 'abcdef', так как lookbehind отступит на 3 символа назад и проверит, совпадает ли содержащийся шаблон. Содержащийся шаблон должен соответствовать только строкам некоторой фиксированной длины, то есть abc или a|b допустимы, а a* и a{3,4} - нет. Обратите внимание, что шаблоны, начинающиеся с положительных утверждений lookbehind, не будут совпадать с началом искомой строки; скорее всего, вы захотите использовать функцию 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: Добавлена поддержка групповых ссылок фиксированной длины.

(?<!...)

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

(?(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>'.

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

\number

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

\A

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

\b

Сопоставляет пустую строку, но только в начале или конце слова. Слово определяется как последовательность символов слова. Обратите внимание, что формально \b определяется как граница между символами \w и \W (или наоборот), или между \w и началом/концом строки. Это означает, что r'\bfoo\b' соответствует 'foo', 'foo.', '(foo)', 'bar foo baz', но не 'foobar' или 'foo3'.

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

\B

Совпадает с пустой строкой, но только если она не находится в начале или конце слова. Это означает, что r'py\B' соответствует 'python', 'py3', 'py2', но не 'py', 'py.' или 'py!'. \B является противоположностью \b, поэтому символами слов в шаблонах Юникода являются алфавитно-цифровые символы Юникода или символ подчеркивания, хотя это можно изменить с помощью флага ASCII. Границы слов определяются текущей локалью, если используется флаг LOCALE.

\d

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

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

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

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

\D

Сопоставляет любой символ, не являющийся десятичной цифрой. Это противоположность \d. Если используется флаг ASCII, это становится эквивалентом [^0-9].

\s

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

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

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

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

\S

Сопоставляет любой символ, который не является символом пробела. Это противоположность \s. Если используется флаг ASCII, это становится эквивалентом [^ \t\n\r\f\v].

\w

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

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

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

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

\W

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

\Z

Выполняет поиск только в конце строки.

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

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

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

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

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

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

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

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

Скомпилированные объекты регулярных выражений поддерживают следующие методы и атрибуты:

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

Просмотреть строку в поисках первого места, где данное регулярное выражение дает совпадение, и вернуть соответствующее значение match object. Верните 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 object. Верните 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'>

Если вы хотите найти совпадение в любом месте строки, используйте search() (см. также поиск() против совпадения()).

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

Если вся строка соответствует данному регулярному выражению, возвращается соответствующее значение match object. Верните 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¶

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

Pattern.groups¶

Количество групп захвата в детали.

Pattern.groupindex¶

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

Pattern.pattern¶

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

Соответствие объектов¶

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

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

Объекты соответствия поддерживают следующие методы и атрибуты:

Match.expand(template)¶

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

Изменено в версии 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'

Добавлено в версии 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() метода regex object. Это индекс строки, по которому механизм RE начал поиск совпадения.

Match.endpos¶

Значение endpos, которое было передано в метод search() или match() метода regex object. Это индекс строки, дальше которого механизм RE не пойдет.

Match.lastindex¶

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

Match.lastgroup¶

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

Match.re¶

regular expression object, чей метод 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.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, 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, 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)