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

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

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

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

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

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

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

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

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

'.'

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

'^'

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

'$'

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

'*'

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

'+'

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

'?'

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

*?, +?, ??

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

Заставляет результирующее РВ соответствовать от 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 (определены ниже), также принимаются внутри набора, хотя символы, которым они соответствуют, зависят от того, активен ли режим LOCALE или UNICODE.

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

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

'|'

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

(...)

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

(?...)

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

(?iLmsux)

(Одна или несколько букв из набора 'i', 'L', 'm', 's', 'u', 'x'.) Группа соответствует пустой строке; буквы устанавливают соответствующие флаги: re.I (игнорировать регистр), re.L (зависит от локали), re.M (многострочный), re.S (точка соответствует всем символам), re.U (зависит от Unicode) и 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.

(?#...)

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

(?=...)

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

(?!...)

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

(?<=...)

Соответствует, если текущей позиции в строке предшествует совпадение с ..., которое заканчивается на текущей позиции. Это называется положительной ретроспективной проверкой (positive lookbehind assertion). (?<=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 или именем существует, и с no-pattern, если не существует. no-pattern необязателен и может быть опущен. Например, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>) – это плохой шаблон для сопоставления адресов электронной почты, который будет соответствовать '<user@host.com>', а также 'user@host.com', но не '<user@host.com'.

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

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

\number

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

\A

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

\b

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

\B

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

\d

Когда флаг UNICODE не указан, соответствует любой десятичной цифре; это эквивалентно набору [0-9]. С UNICODE он будет соответствовать всему, что классифицируется как десятичная цифра в базе данных свойств символов Unicode.

\D

Когда флаг UNICODE не указан, соответствует любому нецифровому символу; это эквивалентно набору [^0-9]. С UNICODE он будет соответствовать любому символу, кроме тех, которые отмечены как цифры в базе данных свойств символов Unicode.

\s

Когда флаг UNICODE не указан, соответствует любому пробельному символу; это эквивалентно набору [ \t\n\r\f\v]. Флаг LOCALE не оказывает дополнительного влияния на сопоставление пробела. Если установлен UNICODE, он будет соответствовать символам [ \t\n\r\f\v] плюс всему, что классифицируется как пробел в базе данных свойств символов Unicode.

\S

Когда флаг UNICODE не указан, соответствует любому непробельному символу; это эквивалентно набору [^ \t\n\r\f\v]. Флаг LOCALE не оказывает дополнительного влияния на сопоставление непробельных символов. Если установлен UNICODE, то будет соответствовать любой символ, не отмеченный как пробел в базе данных свойств символов Unicode.

\w

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

\W

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

\Z

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

Если для конкретной последовательности указаны оба флага LOCALE и UNICODE, то сначала вступает в силу флаг LOCALE, а затем UNICODE.

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

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

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

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

7.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.match(), re.search() или re.compile(), кэшируются, поэтому программам, использующим лишь несколько регулярных выражений за раз, не нужно беспокоиться о компиляции регулярных выражений.

re.DEBUG¶

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

re.I¶

re.IGNORECASE¶

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

re.L¶

re.LOCALE¶

Делает \w, \W, \b, \B, \s и \S зависимыми от текущей локали.

re.M¶

re.MULTILINE¶

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

re.S¶

re.DOTALL¶

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

re.U¶

re.UNICODE¶

Делает последовательности \w, \W, \b, \B, \d, \D, \s и \S зависимыми от базы данных свойств символов Unicode. Также включает сопоставление не-ASCII символов для IGNORECASE.

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

re.X¶

re.VERBOSE¶

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

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

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)¶

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

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

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

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

If you want to locate a match anywhere in string, use search() instead (see also search() vs. match()).

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

Разделяет строку по вхождениям шаблона. Если в шаблоне используются захватывающие скобки, то текст всех групп из шаблона также возвращается как часть результирующего списка. Если maxsplit не равно нулю, происходит не более maxsplit разбиений, и оставшаяся часть строки возвращается как последний элемент списка. (Примечание о несовместимости: в оригинальном выпуске Python 1.5 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', '...', '']

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

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

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

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

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

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

Примечание

Из-за ограничения текущей реализации символ, следующий за пустым совпадением, не включается в следующее совпадение, поэтому findall(r'^|\w+', 'two words') возвращает ['', 'wo', 'words'] (обратите внимание на пропущенную «t»). Это изменено в Python 3.7.

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

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

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

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

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

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

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

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

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

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

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

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

re.escape(pattern)¶

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

>>> print re.escape('python.exe')
python\.exe

>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print '[%s]+' % re.escape(legal_chars)
[abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^\_\`\|\~\:]+

>>> operators = ['+', '-', '*', '/', '**']
>>> print '|'.join(map(re.escape, sorted(operators, reverse=True)))
\/|\-|\+|\*\*|\*

re.purge()¶

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

exception re.error¶

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

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

class re.RegexObject¶

Класс RegexObject поддерживает следующие методы и атрибуты:

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

Просматривает string в поисках позиции, для которой данное регулярное выражение даёт совпадение, и возвращает соответствующий экземпляр MatchObject. Возвращает 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 at ...>
>>> pattern.search("dog", 1)  # Совпадения нет; поиск не включает "d"

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

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

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

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

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

split(string, maxsplit=0)¶

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

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

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

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

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

sub(repl, string, count=0)¶

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

subn(repl, string, count=0)¶

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

flags¶

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

groups¶

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

groupindex¶

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

pattern¶

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

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

class re.MatchObject¶

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

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

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

expand(template)¶

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

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'

groups([default])¶

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

Например:

>>> 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')

groupdict([default])¶

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

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

start([group])¶

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'

span([group])¶

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

pos¶

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

endpos¶

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

lastindex¶

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

lastgroup¶

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

re¶

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

string¶

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

7.2.5. Примеры¶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 at ...>

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

>>> re.match('X', 'A\nB\nX', re.MULTILINE)  # Нет совпадения.
>>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Совпадает.
<_sre.SRE_Match object at ...>

>>> 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 at ...>
>>> re.match("\\W(.)\\1\\W", " ff ")
<_sre.SRE_Match object at ...>

>>> re.match(r"\\", r"\\")
<_sre.SRE_Match object at ...>
>>> re.match("\\\\", r"\\")
<_sre.SRE_Match object at ...>