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

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

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

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

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

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

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

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

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

.

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

^

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

$

Соответствует концу строки или непосредственно перед символом новой строки в конце строки, а в режиме MULTILINE также соответствует перед символом новой строки. foo соответствует и ‘foo’, и ‘foobar’, в то время как регулярное выражение foo$ соответствует только ‘foo’. Интереснее то, что поиск foo.$ в 'foo1\nfoo2\n' обычно соответствует ‘foo2’, но в режиме 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’.

*?, +?, ??

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

*+, ++, ?+

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

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

{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 символам.

{m,n}+

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

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

\

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

Если вы не используете сырую строку для выражения шаблона, помните, что 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] или [a-]), он будет совпадать с литералом '-'.

• Специальные символы теряют своё специальное значение внутри наборов. Например, [(+*)] будет соответствовать любому из литеральных символов '(', '+', '*' или ')'.

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

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

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

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

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

|

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.U (сопоставление Unicode)

• re.X (подробный режим)

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

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

(?:...)

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

(?aiLmsux-imsx:...)

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

• re.A (только ASCII)

• re.I (без учёта регистра)

• re.L (зависит от локали)

• re.M (многострочный режим)

• re.S (точка совпадает со всем)

• re.U (сопоставление Unicode)

• re.X (подробный режим)

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

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

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

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

(?>...)

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

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

(?P<name>...)

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

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

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

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

(?P=name)

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

(?#...)

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

(?=...)

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

(?!...)

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

(?<=...)

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

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

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

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

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

(?<!...)

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

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

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

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

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

\number

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

\A

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

\b

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

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

Примечание

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

\B

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

Примечание

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

\d

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

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

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

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

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

\D

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

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

\s

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

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

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

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

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

\S

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

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

\w

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

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

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

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

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

\W

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

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

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

\Z

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

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

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

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

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

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

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

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

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

class re.Pattern¶

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

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

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

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

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

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

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Совпадение на индексе 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # Совпадения нет; поиск не включает "d"

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

If zero or more characters at the beginning of string match this regular expression, return a corresponding Match. Return None if the string does not match the pattern; note that this is different from a zero-length match.

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

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

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

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

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

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

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

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

Pattern.split(string, maxsplit=0)¶

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

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

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

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

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

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

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

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

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

Pattern.flags¶

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

Pattern.groups¶

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

Pattern.groupindex¶

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

Pattern.pattern¶

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

Объекты Match¶Match Objects

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

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

class re.Match¶

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

Изменено в версии 3.9: re.Match поддерживает [] для указания сопоставления Unicode (str) или bytes. См. Generic Alias Type.

Match.expand(template)¶

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

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

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

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

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # Всё совпадение
'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.__getitem__(g)¶

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

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0]       # Всё совпадение
'Isaac Newton'
>>> m[1]       # Первая группа в скобках.
'Isaac'
>>> m[2]       # Вторая группа в скобках.
'Newton'

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

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

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

Match.groups(default=None)¶

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

Например:

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

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

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Вторая группа по умолчанию – 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¶

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

Match.endpos¶

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

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

Примеры регулярных выражений¶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 = 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")    # Нет совпадения.
>>> re.search("c", "abcdef")   # Совпадает.
<re.Match object; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Совпадает.
<re.Match object; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") # Нет совпадения.

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

>>> re.match("X", "A\nB\nX", re.MULTILINE)  # Нет совпадения.
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Совпадает.
<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*)?'),  # Целое или десятичное число.
        ('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()
        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)