6.2. re – Операции с регулярными выражениями¶re – Regular expression operations

6.2.1. Синтаксис регулярных выражений¶Regular Expression Syntax

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

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

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

Регулярные выражения могут содержать как специальные, так и обычные символы. Большинство обычных символов, например 'A', 'a' или '0', – это простейшие регулярные выражения: они просто соответствуют сами себе. Можно объединять обычные символы, так что last соответствует строке 'last'. (В остальной части этого раздела мы будем записывать регулярные выражения таким специальным стилем, обычно без кавычек, а строки для поиска – 'в одинарных кавычках'.)

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

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

'.'

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

'^'

(Циркумфлекс.) Соответствует началу строки, а в режиме MULTILINE также соответствует позиции сразу после каждого перевода строки.

'$'

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

'*'

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

'+'

Заставляет результирующее регулярное выражение соответствовать 1 или более повторениям предшествующего выражения. ab+ будет соответствовать 'a', за которым следует любое ненулевое количество 'b'; одному 'a' оно не соответствует.

'?'

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

*?, +?, ??

Квантификаторы '*', '+' и '?' являются жадными; они захватывают максимально возможный текст. Иногда такое поведение нежелательно; если регулярное выражение <.*> применить к строке '<H1>title</H1>', оно совпадет со всей строкой, а не только с '<H1>'. Добавление '?' после квантификатора заставляет его выполнять сопоставление в нежадном или минимальном режиме; при этом будет захвачено наименьшее количество символов. Используя .*? в предыдущем выражении, мы получим соответствие только '<H1>'.

{m}

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

{m,n}

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

{m,n}?

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

'\'

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

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

[]

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

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

'|'

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

Обратите внимание, что флаг (?x) изменяет способ разбора выражения. Он должен быть указан первым в строке выражения или после одного или нескольких пробельных символов. Если перед флагом есть непробельные символы, результат не определён.

(?:...)

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

(?P<name>...)

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

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

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

(?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('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

(?<!...)

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

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

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

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

\number

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

\A

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

\b

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

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

\B

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

\d

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

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

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

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

\D

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

\s

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

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

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

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

\S

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

\w

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

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

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

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

\W

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

\Z

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

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

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

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

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

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

6.2.2. Содержимое модуля¶Module Contents

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

re.compile(pattern, flags=0)¶

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

Поведение выражения можно изменить, указав значение flags. В качестве значений можно использовать любые из следующих переменных, комбинируя их с помощью побитового ИЛИ (оператор |).

Последовательность

prog = re.compile(pattern)
result = prog.match(string)

эквивалентна

result = re.match(pattern, string)

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

Примечание

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

re.A¶

re.ASCII¶

Заставляет \w, \W, \b, \B, \d, \D, \s и \S выполнять сопоставление только из ASCII вместо полного сопоставления Unicode. Это имеет смысл только для шаблонов Unicode и игнорируется для байтовых шаблонов.

Обратите внимание, что для обратной совместимости флаг re.U всё ещё существует (как и его синоним re.UNICODE и его встроенный аналог (?u)), но они избыточны в Python 3, так как сопоставление по умолчанию для строк выполняется с Unicode (а сопоставление Unicode не допускается для байтов).

re.DEBUG¶

Отображает отладочную информацию о скомпилированном выражении.

re.I¶

re.IGNORECASE¶

Выполняет сопоставление без учёта регистра; выражения вроде [A-Z] будут соответствовать также и строчным буквам. На это не влияет текущая локаль, и оно работает с символами Unicode так, как и ожидается.

re.L¶

re.LOCALE¶

Заставляет \w, \W, \b, \B, \s и \S зависеть от текущей локали. Использование этого флага не рекомендуется, так как механизм локали очень ненадёжен и в любом случае обрабатывает только одну «культуру» за раз; вместо этого следует использовать сопоставление Unicode, которое является стандартным в Python 3 для шаблонов Unicode (str).

re.M¶

re.MULTILINE¶

При указании этого флага символ шаблона '^' совпадает с началом строки и с началом каждой строки (сразу после каждого перевода строки); а символ шаблона '$' совпадает с концом строки и с концом каждой строки (непосредственно перед каждым переводом строки). По умолчанию '^' совпадает только с началом строки, а '$' – только с концом строки и непосредственно перед переводом строки (если он есть) в конце строки.

re.S¶

re.DOTALL¶

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

re.X¶

re.VERBOSE¶

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

Это означает, что следующие два объекта регулярных выражений, которые сопоставляют десятичное число, функционально эквивалентны:

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

re.search(pattern, string, flags=0)¶

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

re.match(pattern, string, flags=0)¶

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

Обратите внимание, что даже в режиме MULTILINE функция re.match() находит совпадение только в начале строки, а не в начале каждой строки.

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

re.fullmatch(pattern, string, flags=0)¶

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

Новое в версии 3.4.

re.split(pattern, string, maxsplit=0, flags=0)¶

Разделяет string по вхождениям pattern. Если в pattern используются захватывающие круглые скобки, то текст всех групп в шаблоне также возвращается как часть результирующего списка. Если maxsplit не равно нулю, то происходит не более maxsplit разбиений, а остаток строки возвращается как последний элемент списка.

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

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

>>> re.split('(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

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

Обратите внимание, что split никогда не разделяет строку по пустому совпадению шаблона. Например:

>>> re.split('x*', 'foo')
['foo']
>>> re.split("(?m)^$", "foo\n\nbar\n")
['foo\n\nbar\n']

Изменено в версии 3.1: Добавлен необязательный аргумент flags.

re.findall(pattern, string, flags=0)¶

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

re.finditer(pattern, string, flags=0)¶

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

re.sub(pattern, repl, string, count=0, flags=0)¶

Возвращает строку, полученную заменой крайних левых непересекающихся вхождений pattern в string на замену repl. Если шаблон не найден, возвращается string без изменений. repl может быть строкой или функцией; если это строка, все обратные слеши в ней обрабатываются. То есть \n преобразуется в символ новой строки, \r – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как \j, остаются без изменений. Обратные ссылки, такие как \6, заменяются подстрокой, соответствующей группе 6 в шаблоне. Например:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

Если repl – функция, она вызывается для каждого непересекающегося вхождения pattern. Функция принимает один аргумент – объект совпадения – и возвращает строку замены. Например:

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'

Шаблон может быть строкой или объектом RE.

Необязательный аргумент count – это максимальное количество заменяемых вхождений шаблона; count должен быть неотрицательным целым числом. Если опущено или равно нулю, заменяются все вхождения. Пустые совпадения шаблона заменяются только тогда, когда они не примыкают к предыдущему совпадению, поэтому sub('x*', '-', 'abc') возвращает '-a-b-c-'.

В строковых аргументах repl, помимо escape-последовательностей символов и обратных ссылок, описанных выше, \g<name> использует подстроку, соответствующую группе с именем name, как определено синтаксисом (?P<name>...). \g<number> использует соответствующий номер группы; \g<2> поэтому эквивалентно \2, но не является неоднозначным в замене такой как \g<2>0. \20 было бы интерпретировано как ссылка на группу 20, а не как ссылка на группу 2, за которой следует литеральный символ '0'. Обратная ссылка \g<0> заменяет всей подстрокой, соответствующей регулярному выражению.

Изменено в версии 3.1: Добавлен необязательный аргумент flags.

re.subn(pattern, repl, string, count=0, flags=0)¶

Выполняет ту же операцию, что и sub(), но возвращает кортеж (new_string, number_of_subs_made).

Изменено в версии 3.1: Добавлен необязательный аргумент flags.

re.escape(string)¶

Экранирует все символы в шаблоне, кроме букв ASCII, цифр и '_'. Это полезно, если нужно сопоставить произвольную литеральную строку, которая может содержать метасимволы регулярных выражений.

Изменено в версии 3.3: Символ '_' больше не экранируется.

re.purge()¶

Очищает кэш регулярных выражений.

exception re.error¶

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

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

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

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

Просматривает string в поиске позиции, где это регулярное выражение даёт совпадение, и возвращает соответствующий объект совпадения. Возвращает 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")     # Совпадение на индексе 0
<_sre.SRE_Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # Совпадения нет; поиск не включает "d"

regex.match(string[, pos[, endpos]])¶

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

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

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # Совпадения нет, так как "o" не в начале строки "dog".
>>> pattern.match("dog", 1)   # Совпадение есть, так как "o" – второй символ строки "dog".
<_sre.SRE_Match object; span=(1, 2), match='o'>

Чтобы найти совпадение в любом месте string, используйте search() (см. также search() vs. match()).

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

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

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

>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog")      # Совпадения нет, так как "o" не в начале строки "dog".
>>> pattern.fullmatch("ogre")     # Совпадения нет, так как не вся строка совпала.
>>> pattern.fullmatch("doggie", 1, 3)   # Совпадения в заданных пределах.
<_sre.SRE_Match object; span=(1, 3), match='og'>

Новое в версии 3.4.

regex.split(string, maxsplit=0)¶

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

regex.findall(string[, pos[, endpos]])¶

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

regex.finditer(string[, pos[, endpos]])¶

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

regex.sub(repl, string, count=0)¶

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

regex.subn(repl, string, count=0)¶

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

regex.flags¶

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

regex.groups¶

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

regex.groupindex¶

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

regex.pattern¶

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

6.2.4. Объекты совпадений¶Match Objects

Объекты совпадения всегда имеют логическое значение 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>) заменяются содержимым соответствующей группы.

match.group([group1, ...])¶

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

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # Всё совпадение
'Isaac Newton'
>>> m.group(1)       # Первая группа в скобках.
'Isaac'
>>> m.group(2)       # Вторая группа в скобках.
'Newton'
>>> m.group(1, 2)    # Несколько аргументов дают кортеж.
('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")  # Совпадает 3 раза.
>>> m.group(1)                        # Возвращает только последнее совпадение.
'c3'

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()      # Вторая группа по умолчанию – None.
('24', None)
>>> m.groups('0')   # Теперь вторая группа по умолчанию – '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 возвращает кортеж из двух элементов (m.start(group), m.end(group)). Обратите внимание, что если group не участвовал в совпадении, результатом будет (-1, -1). group по умолчанию равен нулю, то есть всё совпадение.

match.pos¶

The value of pos which was passed to the search() or match() method of a regex object. This is the index into the string at which the RE engine started looking for a match.

match.endpos¶

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

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().

6.2.5. Примеры регулярных выражений¶Regular Expression Examples

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"))  # Допустимо.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Недопустимо.
>>> displaymatch(valid.match("akt"))    # Недопустимо.
>>> displaymatch(valid.match("727ak"))  # Допустимо.
"<Match: '727ak', groups=()>"

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Пара семёрок.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # Нет пар.
>>> displaymatch(pair.match("354aa"))     # Пара тузов.
"<Match: '354aa', groups=('a',)>"

>>> 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")  # Нет совпадения.
>>> re.search("c", "abcdef") # Совпадает.
<_sre.SRE_Match object; span=(2, 3), match='c'>

>>> re.match("c", "abcdef")  # Нет совпадения.
>>> re.search("^c", "abcdef") # Нет совпадения.
>>> re.search("^a", "abcdef")  # Совпадает.
<_sre.SRE_Match object; span=(0, 1), match='a'>

>>> re.match('X', 'A\nB\nX', re.MULTILINE)  # Нет совпадения.
>>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Совпадает.
<_sre.SRE_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", text)
['carefully', 'quickly']

>>> text = "He was carefully disguised but captured quickly by police."
>>> for m in re.finditer(r"\w+ly", 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 ")
<_sre.SRE_Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<_sre.SRE_Match object; span=(0, 4), match=' ff '>

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

import collections
import re

Token = collections.namedtuple('Token', ['typ', 'value', 'line', 'column'])

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',  r'\d+(\.\d*)?'), # Целое или десятичное число.
        ('ASSIGN',  r':='),          # Оператор присваивания.
        ('END',     r';'),           # Терминатор инструкции.
        ('ID',      r'[A-Za-z]+'),   # Идентификаторы.
        ('OP',      r'[+\-*/]'),     # Арифметические операторы.
        ('NEWLINE', r'\n'),          # Концы строк.
        ('SKIP',    r'[ \t]+'),      # Пропускать пробелы и табуляции.
        ('MISMATCH',r'.'),           # Любой другой символ.
    ]
    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(kind)
        if kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
        elif kind == 'SKIP':
            pass
        elif kind == 'MISMATCH':
            raise RuntimeError('%r unexpected on line %d' % (value, line_num))
        else:
            if kind == 'ID' and value in keywords:
                kind = value
            column = mo.start() - line_start
            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(typ='IF', value='IF', line=2, column=4)
Token(typ='ID', value='quantity', line=2, column=7)
Token(typ='THEN', value='THEN', line=2, column=16)
Token(typ='ID', value='total', line=3, column=8)
Token(typ='ASSIGN', value=':=', line=3, column=14)
Token(typ='ID', value='total', line=3, column=17)
Token(typ='OP', value='+', line=3, column=23)
Token(typ='ID', value='price', line=3, column=25)
Token(typ='OP', value='*', line=3, column=31)
Token(typ='ID', value='quantity', line=3, column=33)
Token(typ='END', value=';', line=3, column=41)
Token(typ='ID', value='tax', line=4, column=8)
Token(typ='ASSIGN', value=':=', line=4, column=12)
Token(typ='ID', value='price', line=4, column=15)
Token(typ='OP', value='*', line=4, column=21)
Token(typ='NUMBER', value='0.05', line=4, column=23)
Token(typ='END', value=';', line=4, column=27)
Token(typ='ENDIF', value='ENDIF', line=5, column=4)
Token(typ='END', value=';', line=5, column=9)