re.md
1> **Источник:** https://python-all.ru/3.2/library/re.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 6.2. [`re`](https://python-all.ru/3.2/library/re.html#module-re) – Операции с регулярными выражениями89Этот модуль предоставляет операции сопоставления с регулярными выражениями, аналогичные тем, что есть в Perl.1011И паттерны, и искомые строки могут быть как строками Unicode, так и 8-битными строками. Однако строки Unicode и 8-битные строки нельзя смешивать: нельзя сопоставить строку Unicode с байтовым паттерном или наоборот; аналогично, при запросе замены строка замены должна быть того же типа, что и паттерн, и искомая строка.1213В регулярных выражениях обратная косая черта (`'\'`) используется для обозначения специальных форм или чтобы разрешить использование специальных символов без их специального значения. Это противоречит использованию того же символа в Python для той же цели в строковых литералах; например, чтобы сопоставить буквальную обратную косую черту, возможно, придётся написать `'\\\\'` в строке шаблона, потому что регулярное выражение должно быть `\\`, а каждую обратную косую черту нужно выразить как `\\` внутри обычного строкового литерала Python.1415Решение – использовать raw-строки Python для паттернов регулярных выражений; обратная косая черта не обрабатывается особым образом в строковом литерале с префиксом `'r'`. Так что `r"\n"` – это двухсимвольная строка, содержащая `'\'` и `'n'`, в то время как `"\n"` – односимвольная строка, содержащая символ новой строки. Обычно паттерны записывают в коде Python с использованием этой raw-нотации.1617Важно отметить, что большинство операций с регулярными выражениями доступны как функции уровня модуля и методы [*скомпилированных регулярных выражений*](https://python-all.ru/3.2/library/re.html#re-objects). Функции – это ярлыки, которые не требуют предварительной компиляции объекта regex, но не имеют некоторых параметров тонкой настройки.1819> **См. также**20>21> **Освоение регулярных выражений**22>23> Книга по регулярным выражениям Джеффри Фридла, издательство O’Reilly. Второе издание книги вообще не охватывает Python, но первое издание очень подробно описывает написание хороших шаблонов регулярных выражений.2425## 6.2.1. Синтаксис регулярных выражений2627Регулярное выражение (или RE) задаёт набор строк, которым оно соответствует; функции в этом модуле позволяют проверить, соответствует ли конкретная строка заданному регулярному выражению (или соответствует ли заданное регулярное выражение конкретной строке – что одно и то же).2829Регулярные выражения можно объединять для получения новых регулярных выражений; если *A* и *B* – регулярные выражения, то *AB* тоже регулярное выражение. В общем, если строка *p* соответствует *A*, а другая строка *q* соответствует *B*, то строка *pq* будет соответствовать AB. Это верно, если только *A* или *B* не содержат операций с низким приоритетом, граничных условий между *A* и *B* или нумерованных обращений к группам. Таким образом, сложные выражения легко строятся из более простых примитивных выражений, подобных описанным здесь. Подробнее о теории и реализации регулярных выражений см. книгу Фридла, указанную выше, или почти любой учебник по построению компиляторов.3031Далее следует краткое объяснение формата регулярных выражений. Для получения дополнительной информации и более доступного изложения обратитесь к [*руководству по регулярным выражениям*](https://python-all.ru/3.2/howto/regex.html#regex-howto).3233Регулярные выражения могут содержать как специальные, так и обычные символы. Большинство обычных символов, например `'A'`, `'a'` или `'0'`, – это простейшие регулярные выражения: они просто соответствуют сами себе. Можно объединять обычные символы, так что `last` соответствует строке `'last'`. (В остальной части этого раздела мы будем записывать регулярные выражения `таким специальным стилем`, обычно без кавычек, а строки для поиска – `'в одинарных кавычках'`.)3435Некоторые символы, такие как `'|'` или `'('`, являются специальными. Специальные символы либо обозначают классы обычных символов, либо влияют на то, как интерпретируются окружающие их регулярные выражения. Строки паттернов регулярных выражений не могут содержать нулевые байты, но можно указать нулевой байт с помощью нотации `\number`, например `'\x00'`.3637Специальные символы:3839**`'.'`**4041(Точка.) В режиме по умолчанию соответствует любому символу, кроме перевода строки. Если указан флаг4243[`DOTALL`](https://python-all.ru/3.2/library/re.html#re.DOTALL)4445, соответствует любому символу, включая перевод строки.4647**`'^'`**4849(Циркумфлекс.) Соответствует началу строки, а в режиме5051[`MULTILINE`](https://python-all.ru/3.2/library/re.html#re.MULTILINE)5253также соответствует позиции сразу после каждого перевода строки.5455**`'$'`**5657Соответствует концу строки или позиции перед символом новой строки в конце строки, а в режиме5859[`MULTILINE`](https://python-all.ru/3.2/library/re.html#re.MULTILINE)6061также соответствует перед переводом строки.6263`foo`6465соответствует и 'foo', и 'foobar', а регулярное выражение6667`foo$`6869соответствует только 'foo'. Ещё интереснее: поиск7071`foo.$`7273в7475`'foo1\nfoo2\n'`7677обычно находит 'foo2', но в режиме7879[`MULTILINE`](https://python-all.ru/3.2/library/re.html#re.MULTILINE)8081– 'foo1'; поиск одного8283`$`8485в8687`'foo\n'`8889найдёт два (пустых) совпадения: одно перед переводом строки, и одно в конце строки.9091**`'*'`**9293Заставляет результирующее регулярное выражение соответствовать 0 или более повторениям предшествующего выражения, захватывая максимально возможное количество повторений.9495`ab*`9697будет соответствовать 'a', 'ab' или 'a', за которым следует любое количество 'b'.9899**`'+'`**100101Заставляет результирующее регулярное выражение соответствовать 1 или более повторениям предшествующего выражения.102103`ab+`104105будет соответствовать 'a', за которым следует любое ненулевое количество 'b'; одному 'a' оно не соответствует.106107**`'?'`**108109Заставляет результирующее регулярное выражение соответствовать 0 или 1 повторению предшествующего выражения.110111`ab?`112113будет соответствовать либо 'a', либо 'ab'.114115**`*?`, `+?`, `??`**116117Квантификаторы118119`'*'`120121,122123`'+'`124125и126127`'?'`128129являются130131*жадными*132133; они захватывают максимально возможный текст. Иногда такое поведение нежелательно; если регулярное выражение134135`<.*>`136137применить к строке138139`'<H1>title</H1>'`140141, оно совпадет со всей строкой, а не только с142143`'<H1>'`144145. Добавление146147`'?'`148149после квантификатора заставляет его выполнять сопоставление в150151*нежадном*152153или154155*минимальном*156157режиме; при этом будет захвачено158159*наименьшее количество*160161символов. Используя162163`.*?`164165в предыдущем выражении, мы получим соответствие только166167`'<H1>'`168169.170171**`{m}`**172173Указывает, что должно быть сопоставлено ровно174175*m*176177копий предшествующего регулярного выражения; если совпадений меньше, всё регулярное выражение не срабатывает. Например,178179`a{6}`180181будет соответствовать ровно шести символам182183`'a'`184185, но не пяти.186187**`{m,n}`**188189Заставляет результирующее регулярное выражение соответствовать от190191*m*192193до194195*n*196197повторений предшествующего выражения, пытаясь захватить максимальное количество повторений. Например,198199`a{3,5}`200201будет соответствовать от 3 до 5 символов202203`'a'`204205. Пропуск206207*m*208209задаёт нижнюю границу, равную нулю, а пропуск210211*n*212213– бесконечную верхнюю границу. Например,214215`a{4,}b`216217будет соответствовать218219`aaaab`220221или тысяче символов222223`'a'`224225, за которыми следует226227`b`228229, но не230231`aaab`232233. Запятая не может быть опущена, иначе модификатор будет спутан с ранее описанной формой.234235**`{m,n}?`**236237Заставляет результирующее регулярное выражение соответствовать от238239*m*240241до242243*n*244245повторений предшествующего выражения, пытаясь захватить как можно246247*меньше*248249повторений. Это нежадная версия предыдущего квантификатора. Например, на 6-символьной строке250251`'aaaaaa'`252253выражение254255`a{3,5}`256257совпадет с 5 символами258259`'a'`260261, тогда как262263`a{3,5}?`264265– только с 3.266267**`'\'`**268269Либо экранирует специальные символы (позволяя сопоставлять такие символы, как `'*'`, `'?'` и т.д.), либо обозначает специальную последовательность; специальные последовательности рассматриваются ниже.270271Если вы не используете сырую строку для выражения шаблона, помните, что Python также использует обратную косую черту как escape-последовательность в строковых литералах; если escape- последовательность не распознаётся парсером Python, обратная косая черта и следующий за ней символ включаются в результирующую строку. Однако если Python распознает результирующую последовательность, обратную косую черту следует удвоить. Это сложно и трудно для понимания, поэтому настоятельно рекомендуется использовать сырые строки для всех, кроме самых простых выражений.272273**`[]`**274275Используется для обозначения набора символов. В наборе:276277- Символы можно перечислять по отдельности, например `[amk]` будет соответствовать `'a'`, `'m'` или `'k'`.278- Диапазоны символов можно задавать, указывая два символа и разделяя их `'-'`, например `[a-z]` будет соответствовать любой строчной букве ASCII, `[0-5][0-9]` – всем двузначным числам от `00` до `59`, а `[0-9A-Fa-f]` – любой шестнадцатеричной цифре. Если `-` экранирован (например `[a\-z]`) или стоит первым или последним символом (например `[a-]`), он будет соответствовать литералу `'-'`.279- Специальные символы теряют своё специальное значение внутри наборов. Например, `[(+*)]` будет соответствовать любому из литеральных символов `'('`, `'+'`, `'*'` или `')'`.280- Классы символов, такие как `\w` или `\S` (определены ниже), также допускаются внутри набора, хотя символы, которым они соответствуют, зависят от того, активен ли режим [`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII) или [`LOCALE`](https://python-all.ru/3.2/library/re.html#re.LOCALE).281- Символы, не входящие в диапазон, можно сопоставить с помощью *дополнения* набора. Если первый символ набора – `'^'`, то будут сопоставлены все символы, которые *не* входят в набор. Например, `[^5]` совпадет с любым символом, кроме `'5'`, а `[^^]` – с любым символом, кроме `'^'`. `^` не имеет специального значения, если он не первый символ в наборе.282- Чтобы найти символ `']'` внутри набора, поставьте перед ним обратную косую черту или поместите его в начало набора. Например, `[()[\]{}]` и `[]()[{}]` оба соответствуют круглой скобке.283284**`'|'`**285286`A|B`287288, где A и B могут быть произвольными регулярными выражениями, создает регулярное выражение, которое будет соответствовать либо A, либо B. Таким способом можно разделять произвольное количество регулярных выражений с помощью289290`'|'`291292. Это можно использовать и внутри групп (см. ниже). При сканировании целевой строки выражения, разделенные293294`'|'`295296, пробуются слева направо. Когда один паттерн полностью совпадает, эта ветвь принимается. Это означает, что как только297298`A`299300совпадает,301302`B`303304больше не проверяется, даже если оно дало бы более длинное совпадение. Другими словами, оператор305306`'|'`307308никогда не бывает жадным. Чтобы сопоставить литерал309310`'|'`311312, используйте313314`\|`315316или заключите его в символьный класс, например317318`[|]`319320.321322**`(...)`**323324Соответствует любому регулярному выражению внутри скобок и обозначает начало и конец группы; содержимое группы можно получить после выполнения сопоставления, а также сопоставить позже в строке с помощью специальной последовательности325326`\number`327328, описанной ниже. Чтобы сопоставить литералы329330`'('`331332или333334`')'`335336, используйте337338`\(`339340или341342`\)`343344, или заключите их в символьный класс:345346`[(] [)]`347348.349350**`(?...)`**351352Это нотация расширения (353354`'?'`355356после357358`'('`359360в противном случае не имеет смысла). Первый символ после361362`'?'`363364определяет значение и дальнейший синтаксис конструкции. Расширения обычно не создают новую группу;365366`(?P<name>...)`367368– единственное исключение из этого правила. Ниже перечислены поддерживаемые в настоящее время расширения.369370**`(?aiLmsux)`**371372(Одна или несколько букв из набора `'a'`, `'i'`, `'L'`, `'m'`, `'s'`, `'u'`, `'x'`.) Группа соответствует пустой строке; буквы устанавливают соответствующие флаги: [`re.A`](https://python-all.ru/3.2/library/re.html#re.A) (только ASCII), [`re.I`](https://python-all.ru/3.2/library/re.html#re.I) (игнорировать регистр), [`re.L`](https://python-all.ru/3.2/library/re.html#re.L) (зависит от локали), [`re.M`](https://python-all.ru/3.2/library/re.html#re.M) (многострочный), [`re.S`](https://python-all.ru/3.2/library/re.html#re.S) (точка соответствует всему) и [`re.X`](https://python-all.ru/3.2/library/re.html#re.X) (подробный) для всего регулярного выражения. (Флаги описаны в разделе [*Содержание модуля*](https://python-all.ru/3.2/library/re.html#contents-of-module-re).) Это полезно, если нужно включить флаги в состав регулярного выражения, а не передавать аргумент *flag* в функцию [`re.compile()`](https://python-all.ru/3.2/library/re.html#re.compile).373374Обратите внимание, что флаг `(?x)` изменяет способ разбора выражения. Он должен быть указан первым в строке выражения или после одного или нескольких пробельных символов. Если перед флагом есть непробельные символы, результат не определён.375376**`(?:...)`**377378Незапоминающая версия обычных круглых скобок. Совпадает с любым регулярным выражением внутри скобок, но подстрока, совпавшая с группой,379380*не может*381382быть извлечена после выполнения сопоставления или использована для ссылки позже в шаблоне.383384**`(?P<name>...)`**385386Подобно обычным круглым скобкам, но подстрока, совпавшая с группой, доступна в остальной части регулярного выражения по символическому имени группы *name*. Имена групп должны быть допустимыми идентификаторами Python, и каждое имя группы должно быть определено только один раз в регулярном выражении. Символическая группа также является нумерованной группой, как если бы группа не была именованной. Таким образом, группу с именем `id` в примере ниже также можно использовать как нумерованную группу `1`.387388Например, если шаблон – `(?P<id>[a-zA-Z_]\w*)`, то на группу можно ссылаться по имени в аргументах методов объектов сопоставления, таких как `m.group('id')` или `m.end('id')`, а также по имени в самом регулярном выражении (используя `(?P=id)`) и в тексте замены, передаваемом в `.sub()` (используя `\g<id>`).389390**`(?P=name)`**391392Совпадает с любым текстом, который совпал с ранее определённой группой с именем393394*name*395396.397398**`(?#...)`**399400Комментарий; содержимое скобок просто игнорируется.401402**`(?=...)`**403404Совпадает, если405406`...`407408совпадает далее, но не поглощает ни одного символа строки. Это называется опережающей проверкой. Например,409410`Isaac (?=Asimov)`411412совпадёт с413414`'Isaac '`415416только если за ним следует417418`'Asimov'`419420.421422**`(?!...)`**423424Совпадает, если425426`...`427428не совпадает далее. Это отрицательная опережающая проверка. Например,429430`Isaac (?!Asimov)`431432совпадёт с433434`'Isaac '`435436только если за ним437438*не*439440следует441442`'Asimov'`443444.445446**`(?<=...)`**447448Совпадает, если текущей позиции в строке предшествует совпадение с `...`, которое заканчивается в текущей позиции. Это называется *положительной ретроспективной проверкой (positive lookbehind assertion)*. `(?<=abc)def` найдёт совпадение в `abcdef`, поскольку ретроспективная проверка отступит на 3 символа и проверит, совпадает ли содержащийся шаблон. Содержащийся шаблон должен соответствовать строкам только фиксированной длины, то есть `abc` или `a|b` разрешены, но `a*` и `a{3,4}` – нет. Обратите внимание, что шаблоны, начинающиеся с положительных ретроспективных проверок, не будут совпадать в начале искомой строки; скорее всего, следует использовать функцию [`search()`](https://python-all.ru/3.2/library/re.html#re.search), а не [`match()`](https://python-all.ru/3.2/library/re.html#re.match):449450```python451>>> import re452>>> m = re.search('(?<=abc)def', 'abcdef')453>>> m.group(0)454'def'455```456457Этот пример ищет слово, следующее за дефисом:458459```python460>>> m = re.search('(?<=-)\w+', 'spam-egg')461>>> m.group(0)462'egg'463```464465**`(?<!...)`**466467Совпадает, если текущей позиции в строке не предшествует совпадение с468469`...`470471. Это называется472473*отрицательной ретроспективной проверкой*474475. Аналогично положительным ретроспективным проверкам, вложенный шаблон может соответствовать только строкам фиксированной длины. Шаблоны, начинающиеся с отрицательной ретроспективной проверки, могут совпадать в начале искомой строки.476477**`(?(id/name)yes-pattern|no-pattern)`**478479Пытается совпасть с480481`yes-pattern`482483, если группа с заданным484485*id*486487или488489*name*490491существует, и с492493`no-pattern`494495, если не существует.496497`no-pattern`498499необязателен и может быть опущен. Например,500501`(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)`502503– это плохой шаблон для сопоставления email, который совпадёт с504505`'<user@host.com>'`506507, а также с508509`'user@host.com'`510511, но не с512513`'<user@host.com'`514515и не с516517`'user@host.com>'`518519.520521Специальные последовательности состоят из `'\'` и символа из списка ниже. Если обычный символ отсутствует в списке, то результирующее РВ будет соответствовать второму символу. Например, `\$` соответствует символу `'$'`.522523**`\number`**524525Совпадает с содержимым группы с тем же номером. Группы нумеруются начиная с 1. Например,526527`(.+) \1`528529совпадает с530531`'the the'`532533или534535`'55 55'`536537, но не с538539`'the end'`540541(обратите внимание на пробел после группы). Эта специальная последовательность может использоваться только для сопоставления одной из первых 99 групп. Если первая цифра542543*number*544545равна 0, или546547*number*548549состоит из 3 восьмеричных цифр, она будет интерпретирована не как ссылка на группу, а как символ с восьмеричным значением550551*number*552553. Внутри554555`'['`556557и558559`']'`560561символьного класса все числовые escape-последовательности обрабатываются как символы.562563**`\A`**564565Совпадает только в начале строки.566567**`\b`**568569Совпадает с пустой строкой, но только в начале или конце слова. Слово определяется как последовательность буквенно-цифровых символов Unicode или символа подчёркивания, поэтому конец слова обозначается пробелом или не буквенно-цифровым символом Unicode, не являющимся подчёркиванием. Обратите внимание, что формально `\b` определяется как граница между символом `\w` и символом `\W` (или наоборот), или между `\w` и началом/концом строки. Это означает, что `r'\bfoo\b'` совпадает с `'foo'`, `'foo.'`, `'(foo)'`, `'bar foo baz'`, но не с `'foobar'` или `'foo3'`.570571По умолчанию используются буквенно-цифровые символы Unicode, но это можно изменить с помощью флага [`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII). Внутри диапазона символов `\b` представляет символ backspace для совместимости со строковыми литералами Python.572573**`\B`**574575Совпадает с пустой строкой, но только когда она576577*не*578579находится в начале или конце слова. Это означает, что580581`r'py\B'`582583совпадает с584585`'python'`586587,588589`'py3'`590591,592593`'py2'`594595, но не с596597`'py'`598599,600601`'py.'`602603или604605`'py!'`606607.608609`\B`610611является противоположностью612613`\b`614615, поэтому символами слова являются буквенно-цифровые символы Unicode или подчёркивание, хотя это можно изменить с помощью флага616617[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)618619.620621**`\d`**622623**Для шаблонов Unicode (str):**624625Совпадает с любой десятичной цифрой Unicode (то есть любым символом из категории Unicode \[Nd\]). Сюда входит626627`[0-9]`628629, а также многие другие цифровые символы. Если используется флаг630631[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)632633, совпадает только634635`[0-9]`636637(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное638639`[0-9]`640641).642643**Для 8-битных (байтовых) шаблонов:**644645Соответствует любой десятичной цифре; это эквивалентно646647`[0-9]`648649.650651**`\D`**652653Совпадает с любым символом, не являющимся десятичной цифрой Unicode. Это противоположность654655`\d`656657. Если используется флаг658659[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)660661, это становится эквивалентом662663`[^0-9]`664665(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное666667`[^0-9]`668669).670671**`\s`**672673**Для шаблонов Unicode (str):**674675Совпадает с пробельными символами Unicode (к которым относятся676677`[ \t\n\r\f\v]`678679, а также многие другие символы, например неразрывные пробелы, требуемые правилами типографики во многих языках). Если используется флаг680681[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)682683, совпадает только684685`[ \t\n\r\f\v]`686687(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное688689`[ \t\n\r\f\v]`690691).692693**Для 8-битных (байтовых) шаблонов:**694695Совпадает с символами, считающимися пробельными в наборе символов ASCII; это эквивалентно696697`[ \t\n\r\f\v]`698699.700701**`\S`**702703Совпадает с любым символом, не являющимся пробельным символом Unicode. Это противоположность704705`\s`706707. Если используется флаг708709[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)710711, это становится эквивалентом712713`[^ \t\n\r\f\v]`714715(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное716717`[^ \t\n\r\f\v]`718719).720721**`\w`**722723**Для шаблонов Unicode (str):**724725Совпадает с символами слова Unicode; сюда входят большинство символов, которые могут быть частью слова в любом языке, а также цифры и символ подчёркивания. Если используется флаг726727[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)728729, совпадает только730731`[a-zA-Z0-9_]`732733(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное734735`[a-zA-Z0-9_]`736737).738739**Для 8-битных (байтовых) шаблонов:**740741Совпадает с символами, считающимися буквенно-цифровыми в наборе символов ASCII; это эквивалентно742743`[a-zA-Z0-9_]`744745.746747**`\W`**748749Соответствует любому символу, который не является символом слова Unicode. Это противоположность750751`\w`752753. Если используется флаг754755[`ASCII`](https://python-all.ru/3.2/library/re.html#re.ASCII)756757, это становится эквивалентом758759`[^a-zA-Z0-9_]`760761(но флаг влияет на всё регулярное выражение, поэтому в таких случаях использование явного762763`[^a-zA-Z0-9_]`764765может быть лучшим выбором).766767**`\Z`**768769Совпадение только в конце строки.770771Большинство стандартных управляющих последовательностей, поддерживаемых строковыми литералами Python, также принимаются синтаксическим анализатором регулярных выражений:772773```python774\a \b \f \n775\r \t \v \x776\\777```778779(Обратите внимание, что `\b` используется для обозначения границ слов и означает “backspace” только внутри символьных классов.)780781Восьмеричные управляющие последовательности поддерживаются в ограниченной форме. Если первая цифра – 0, или если есть три восьмеричных цифры, это считается восьмеричной управляющей последовательностью. В противном случае это ссылка на группу. Как и в строковых литералах, восьмеричные управляющие последовательности всегда имеют длину не более трёх цифр.782783## 6.2.2. Содержимое модуля784785Модуль определяет несколько функций, констант и одно исключение. Некоторые из функций являются упрощёнными версиями полнофункциональных методов для скомпилированных регулярных выражений. В большинстве нетривиальных приложений всегда используется скомпилированная форма.786787#### `re.compile(pattern, flags=0)`788789Компилирует шаблон регулярного выражения в объект регулярного выражения, который можно использовать для поиска совпадений с помощью его методов [`match()`](https://python-all.ru/3.2/library/re.html#re.match) и [`search()`](https://python-all.ru/3.2/library/re.html#re.search), описанных ниже.790791Поведение выражения можно изменить, указав значение *flags*. В качестве значений можно использовать любые из следующих переменных, комбинируя их с помощью побитового ИЛИ (оператор `|`).792793Последовательность794795```python796prog = re.compile(pattern)797result = prog.match(string)798```799800эквивалентна801802```python803result = re.match(pattern, string)804```805806но использование [`re.compile()`](https://python-all.ru/3.2/library/re.html#re.compile) и сохранение полученного объекта регулярного выражения для повторного использования более эффективно, когда выражение будет использоваться несколько раз в одной программе.807808> **Примечание**809>810> Скомпилированные версии последних шаблонов, переданных в [`re.match()`](https://python-all.ru/3.2/library/re.html#re.match), [`re.search()`](https://python-all.ru/3.2/library/re.html#re.search) или [`re.compile()`](https://python-all.ru/3.2/library/re.html#re.compile), кэшируются, поэтому программам, использующим лишь несколько регулярных выражений за раз, не нужно беспокоиться о компиляции регулярных выражений.811812#### `re.A`813814#### `re.ASCII`815816Заставляет `\w`, `\W`, `\b`, `\B`, `\d`, `\D`, `\s` и `\S` выполнять сопоставление только из ASCII вместо полного сопоставления Unicode. Это имеет смысл только для шаблонов Unicode и игнорируется для байтовых шаблонов.817818Обратите внимание, что для обратной совместимости флаг `re.U` всё ещё существует (как и его синоним `re.UNICODE` и его встроенный аналог `(?u)`), но они избыточны в Python 3, так как сопоставление по умолчанию для строк выполняется с Unicode (а сопоставление Unicode не допускается для байтов).819820#### `re.DEBUG`821822Отображает отладочную информацию о скомпилированном выражении.823824#### `re.I`825826#### `re.IGNORECASE`827828Выполняет сопоставление без учёта регистра; выражения вроде `[A-Z]` будут соответствовать также и строчным буквам. На это не влияет текущая локаль, и оно работает с символами Unicode так, как и ожидается.829830#### `re.L`831832#### `re.LOCALE`833834Заставляет `\w`, `\W`, `\b`, `\B`, `\s` и `\S` зависеть от текущей локали. Использование этого флага не рекомендуется, так как механизм локали очень ненадёжен и в любом случае обрабатывает только одну «культуру» за раз; вместо этого следует использовать сопоставление Unicode, которое является стандартным в Python 3 для шаблонов Unicode (str).835836#### `re.M`837838#### `re.MULTILINE`839840При указании этого флага символ шаблона `'^'` совпадает с началом строки и с началом каждой строки (сразу после каждого перевода строки); а символ шаблона `'$'` совпадает с концом строки и с концом каждой строки (непосредственно перед каждым переводом строки). По умолчанию `'^'` совпадает только с началом строки, а `'$'` – только с концом строки и непосредственно перед переводом строки (если он есть) в конце строки.841842#### `re.S`843844#### `re.DOTALL`845846Заставляет специальный символ `'.'` совпадать с любым символом, включая перевод строки; без этого флага `'.'` будет совпадать с любым символом, *кроме* перевода строки.847848#### `re.X`849850#### `re.VERBOSE`851852Этот флаг позволяет писать более читаемые регулярные выражения. Пробельные символы в шаблоне игнорируются, кроме случаев, когда они находятся внутри символьного класса или перед ними стоит неэкранированная обратная косая черта. Кроме того, если строка содержит `'#'`, не находящийся в символьном классе и не предварённый неэкранированной обратной косой чертой, все символы от самого левого такого `'#'` до конца строки игнорируются.853854Это означает, что следующие два объекта регулярных выражений, которые соответствуют десятичному числу, функционально эквивалентны:855856```python857a = re.compile(r"""\d + # the integral part858 \. # the decimal point859 \d * # some fractional digits""", re.X)860b = re.compile(r"\d+\.\d*")861```862863#### `re.search(pattern, string, flags=0)`864865Просматривает *string* в поисках позиции, где регулярное выражение *pattern* даёт совпадение, и возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.2/library/re.html#match-objects). Возвращает `None`, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от поиска совпадения нулевой длины в какой-либо точке строки.866867#### `re.match(pattern, string, flags=0)`868869Если ноль или более символов в начале *string* соответствуют регулярному выражению *pattern*, возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.2/library/re.html#match-objects). Возвращает `None`, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.870871Обратите внимание, что даже в режиме [`MULTILINE`](https://python-all.ru/3.2/library/re.html#re.MULTILINE) функция [`re.match()`](https://python-all.ru/3.2/library/re.html#re.match) находит совпадение только в начале строки, а не в начале каждой строки.872873Если нужно найти совпадение в любом месте *string*, используйте [`search()`](https://python-all.ru/3.2/library/re.html#re.search) (см. также [*search() vs. match()*](https://python-all.ru/3.2/library/re.html#search-vs-match)).874875#### `re.split(pattern, string, maxsplit=0, flags=0)`876877Разделяет *string* по вхождениям *pattern*. Если в *pattern* используются захватывающие круглые скобки, то текст всех групп в шаблоне также возвращается как часть результирующего списка. Если *maxsplit* не равно нулю, то происходит не более *maxsplit* разбиений, а остаток строки возвращается как последний элемент списка.878879```python880>>> re.split('\W+', 'Words, words, words.')881['Words', 'words', 'words', '']882>>> re.split('(\W+)', 'Words, words, words.')883['Words', ', ', 'words', ', ', 'words', '.', '']884>>> re.split('\W+', 'Words, words, words.', 1)885['Words', 'words, words.']886>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)887['0', '3', '9']888```889890Если в разделителе есть захватывающие группы и он совпадает в начале строки, результат будет начинаться с пустой строки. То же самое относится и к концу строки:891892```python893>>> re.split('(\W+)', '...words, words...')894['', '...', 'words', ', ', 'words', '...', '']895```896897Таким образом, компоненты разделителя всегда находятся на одних и тех же относительных индексах в результирующем списке.898899Обратите внимание, что *split* никогда не разделяет строку по пустому совпадению шаблона. Например:900901```python902>>> re.split('x*', 'foo')903['foo']904>>> re.split("(?m)^$", "foo\n\nbar\n")905['foo\n\nbar\n']906```907908Изменено в версии 3.1: добавлен необязательный аргумент flags.909910#### `re.findall(pattern, string, flags=0)`911912Возвращает все непересекающиеся совпадения *pattern* в *string*, в виде списка строк. Строка *string* сканируется слева направо, совпадения возвращаются в порядке обнаружения. Если в шаблоне присутствуют одна или несколько групп, возвращается список групп; если групп больше одной – список кортежей. Пустые совпадения включаются в результат, кроме случаев, когда они примыкают к началу другого совпадения.913914#### `re.finditer(pattern, string, flags=0)`915916Возвращает [*итератор*](https://python-all.ru/3.2/glossary.html#term-iterator), выдающий [*объекты совпадений*](https://python-all.ru/3.2/library/re.html#match-objects) по всем непересекающимся совпадениям регулярного выражения *pattern* в *string*. Строка *string* сканируется слева направо, совпадения возвращаются в порядке обнаружения. Пустые совпадения включаются в результат, кроме случаев, когда они примыкают к началу другого совпадения.917918#### `re.sub(pattern, repl, string, count=0, flags=0)`919920Возвращает строку, полученную заменой крайних левых непересекающихся вхождений *pattern* в *string* на замену *repl*. Если шаблон не найден, возвращается *string* без изменений. *repl* может быть строкой или функцией; если это строка, все обратные слеши в ней обрабатываются. То есть `\n` преобразуется в символ новой строки, `\r` – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как `\j`, остаются без изменений. Обратные ссылки, такие как `\6`, заменяются подстрокой, соответствующей группе 6 в шаблоне. Например:921922```python923>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',924... r'static PyObject*\npy_\1(void)\n{',925... 'def myfunc():')926'static PyObject*\npy_myfunc(void)\n{'927```928929Если *repl* – функция, она вызывается для каждого непересекающегося вхождения *pattern*. Функция принимает один аргумент – объект совпадения – и возвращает строку замены. Например:930931```python932>>> def dashrepl(matchobj):933... if matchobj.group(0) == '-': return ' '934... else: return '-'935>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')936'pro--gram files'937>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)938'Baked Beans & Spam'939```940941Шаблон может быть строкой или объектом RE.942943Необязательный аргумент *count* – это максимальное количество заменяемых вхождений шаблона; *count* должен быть неотрицательным целым числом. Если опущено или равно нулю, заменяются все вхождения. Пустые совпадения шаблона заменяются только тогда, когда они не примыкают к предыдущему совпадению, поэтому `sub('x*', '-', 'abc')` возвращает `'-a-b-c-'`.944945В дополнение к экранированию символов и обратным ссылкам, описанным выше, `\g<name>` будет использовать подстроку, совпавшую с группой с именем `name`, как определено синтаксисом `(?P<name>...)`. `\g<number>` использует соответствующий номер группы; `\g<2>` поэтому эквивалентно `\2`, но не является неоднозначным в замене, такой как `\g<2>0`. `\20` было бы интерпретировано как ссылка на группу 20, а не ссылка на группу 2, за которой следует литерал `'0'`. Обратная ссылка `\g<0>` подставляет всю подстроку, совпавшую с регулярным выражением.946947Изменено в версии 3.1: добавлен необязательный аргумент flags.948949#### `re.subn(pattern, repl, string, count=0, flags=0)`950951Выполняет ту же операцию, что и [`sub()`](https://python-all.ru/3.2/library/re.html#re.sub), но возвращает кортеж `(new_string, number_of_subs_made)`.952953Изменено в версии 3.1: добавлен необязательный аргумент flags.954955#### `re.escape(string)`956957Возвращает *string*, в котором все небуквенно-цифровые символы экранированы обратной косой чертой; это полезно, если требуется найти произвольную литеральную строку, которая может содержать метасимволы регулярных выражений.958959#### `re.purge()`960961Очищает кэш регулярных выражений.962963#### `exception re.error`964965Исключение возникает, когда строка, переданная одной из функций здесь, не является допустимым регулярным выражением (например, может содержать непарные скобки) или когда происходит другая ошибка во время компиляции или сопоставления. Это никогда не является ошибкой, если строка не содержит совпадений с шаблоном.966967## 6.2.3. Объекты регулярных выражений968969Скомпилированные объекты регулярных выражений поддерживают следующие методы и атрибуты:970971#### `regex.search(string[, pos[, endpos]])`972973Просматривает *string* в поиске позиции, где это регулярное выражение даёт совпадение, и возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.2/library/re.html#match-objects). Возвращает `None`, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от нахождения совпадения нулевой длины в какой-то точке строки.974975Необязательный второй параметр *pos* задаёт индекс в строке, с которого начинается поиск; по умолчанию `0`. Это не полностью эквивалентно срезу строки; символ шаблона `'^'` сопоставляется с реальным началом строки и с позициями сразу после символа новой строки, но не обязательно с индексом, с которого должен начинаться поиск.976977Необязательный параметр *endpos* ограничивает, насколько далеко будет просматриваться строка; это будет так, как если бы строка имела длину *endpos* символов, поэтому для поиска совпадения будут просматриваться только символы от *pos* до `endpos - 1`. Если *endpos* меньше *pos*, совпадение не будет найдено; в противном случае, если *rx* – скомпилированный объект регулярного выражения, `rx.search(string, 0, 50)` эквивалентно `rx.search(string[:50], 0)`.978979```python980>>> pattern = re.compile("d")981>>> pattern.search("dog") # Совпадение на индексе 0982<_sre.SRE_Match object at ...>983>>> pattern.search("dog", 1) # Совпадения нет; поиск не включает "d"984```985986#### `regex.match(string[, pos[, endpos]])`987988Если ноль или более символов в *начале* *string* соответствуют этому регулярному выражению, возвращается соответствующий [*объект совпадения*](https://python-all.ru/3.2/library/re.html#match-objects). Возвращается `None`, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.989990Необязательные параметры *pos* и *endpos* имеют тот же смысл, что и для метода [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search).991992```python993>>> pattern = re.compile("o")994>>> pattern.match("dog") # Совпадения нет, так как "o" не в начале строки "dog".995>>> pattern.match("dog", 1) # Совпадение есть, так как "o" – второй символ строки "dog".996<_sre.SRE_Match object at ...>997```998999Чтобы найти совпадение в любом месте *string*, используйте [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search) (см. также [*search() vs. match()*](https://python-all.ru/3.2/library/re.html#search-vs-match)).10001001#### `regex.split(string, maxsplit=0)`10021003Идентично функции [`split()`](https://python-all.ru/3.2/library/re.html#re.split), используя скомпилированный шаблон.10041005#### `regex.findall(string[, pos[, endpos]])`10061007Аналогично функции [`findall()`](https://python-all.ru/3.2/library/re.html#re.findall), использующей скомпилированный шаблон, но также принимает необязательные параметры *pos* и *endpos*, ограничивающие область поиска, как в [`match()`](https://python-all.ru/3.2/library/re.html#re.match).10081009#### `regex.finditer(string[, pos[, endpos]])`10101011Аналогично функции [`finditer()`](https://python-all.ru/3.2/library/re.html#re.finditer), использующей скомпилированный шаблон, но также принимает необязательные параметры *pos* и *endpos*, ограничивающие область поиска, как в [`match()`](https://python-all.ru/3.2/library/re.html#re.match).10121013#### `regex.sub(repl, string, count=0)`10141015Идентична функции [`sub()`](https://python-all.ru/3.2/library/re.html#re.sub), использующей скомпилированный шаблон.10161017#### `regex.subn(repl, string, count=0)`10181019Идентична функции [`subn()`](https://python-all.ru/3.2/library/re.html#re.subn), использующей скомпилированный шаблон.10201021#### `regex.flags`10221023Флаги сопоставления регулярного выражения. Это комбинация флагов, переданных в [`compile()`](https://python-all.ru/3.2/library/re.html#re.compile), любых `(?...)` встроенных флагов в шаблоне и неявных флагов, таких как `UNICODE`, если шаблон является строкой Unicode.10241025#### `regex.groups`10261027Количество захватываемых групп в шаблоне.10281029#### `regex.groupindex`10301031Словарь, сопоставляющий любые символьные имена групп, определённые с помощью `(?P<id>)`, с номерами групп. Словарь пуст, если в шаблоне не использовались символьные группы.10321033#### `regex.pattern`10341035Строка шаблона, из которой был скомпилирован объект RE.10361037## 6.2.4. Объекты совпадений10381039Объекты совпадения всегда имеют логическое значение `True`. Поскольку [`match()`](https://python-all.ru/3.2/library/re.html#re.regex.match) и [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search) возвращают `None`, когда совпадения нет, можно проверить наличие совпадения с помощью простого оператора `if`:10401041```python1042match = re.search(pattern, string)1043if match:1044 process(match)1045```10461047Объекты сопоставления поддерживают следующие методы и атрибуты:10481049#### `match.expand(template)`10501051Возвращает строку, полученную в результате замены обратной косой черты в шаблоне строки *template*, как это делает метод [`sub()`](https://python-all.ru/3.2/library/re.html#re.regex.sub). Экранированные последовательности, такие как `\n`, преобразуются в соответствующие символы, а числовые обратные ссылки (`\1`, `\2`) и именованные обратные ссылки (`\g<1>`, `\g<name>`) заменяются содержимым соответствующей группы.10521053#### `match.group([group1, ...])`10541055Возвращает одну или несколько подгрупп совпадения. Если аргумент один, результатом является одна строка; если аргументов несколько, результат – кортеж с одним элементом на каждый аргумент. Без аргументов *group1* по умолчанию равен нулю (возвращается всё совпадение). Если аргумент *groupN* равен нулю, соответствующее возвращаемое значение – вся сопоставленная строка; если он находится в диапазоне \[1..99\] включительно, это строка, соответствующая соответствующей группе в скобках. Если номер группы отрицателен или больше количества групп, определённых в шаблоне, возбуждается исключение [`IndexError`](https://python-all.ru/3.2/library/exceptions.html#IndexError). Если группа содержится в части шаблона, которая не совпала, соответствующий результат равен `None`. Если группа содержится в части шаблона, которая совпала несколько раз, возвращается последнее совпадение.10561057```python1058>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")1059>>> m.group(0) # Всё совпадение1060'Isaac Newton'1061>>> m.group(1) # Первая группа в скобках.1062'Isaac'1063>>> m.group(2) # Вторая группа в скобках.1064'Newton'1065>>> m.group(1, 2) # Несколько аргументов дают кортеж.1066('Isaac', 'Newton')1067```10681069Если в регулярном выражении используется синтаксис `(?P<name>...)`, то аргументы *groupN* могут также быть строками, идентифицирующими группы по их имени. Если строковый аргумент не используется как имя группы в шаблоне, возбуждается исключение [`IndexError`](https://python-all.ru/3.2/library/exceptions.html#IndexError).10701071Довольно сложный пример:10721073```python1074>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")1075>>> m.group('first_name')1076'Malcolm'1077>>> m.group('last_name')1078'Reynolds'1079```10801081Именованные группы также можно указывать по их индексу:10821083```python1084>>> m.group(1)1085'Malcolm'1086>>> m.group(2)1087'Reynolds'1088```10891090Если группа совпадает несколько раз, доступно только последнее совпадение:10911092```python1093>>> m = re.match(r"(..)+", "a1b2c3") # Совпадает 3 раза.1094>>> m.group(1) # Возвращает только последнее совпадение.1095'c3'1096```10971098#### `match.groups(default=None)`10991100Возвращает кортеж, содержащий все подгруппы совпадения, от 1 до количества групп в шаблоне. Аргумент *default* используется для групп, которые не участвовали в совпадении; по умолчанию он равен `None`.11011102Например:11031104```python1105>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")1106>>> m.groups()1107('24', '1632')1108```11091110Если сделать десятичную точку и всё после неё необязательными, не все группы могут участвовать в совпадении. Эти группы по умолчанию будут равны `None`, если не указан аргумент *default*:11111112```python1113>>> m = re.match(r"(\d+)\.?(\d+)?", "24")1114>>> m.groups() # Вторая группа по умолчанию – None.1115('24', None)1116>>> m.groups('0') # Теперь вторая группа по умолчанию – '0'.1117('24', '0')1118```11191120#### `match.groupdict(default=None)`11211122Возвращает словарь, содержащий все *именованные* подгруппы совпадения, где ключом является имя подгруппы. Аргумент *default* используется для групп, которые не участвовали в совпадении; по умолчанию он равен `None`. Например:11231124```python1125>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")1126>>> m.groupdict()1127{'first_name': 'Malcolm', 'last_name': 'Reynolds'}1128```11291130#### `match.start([group])`11311132#### `match.end([group])`11331134Возвращает индексы начала и конца подстроки, сопоставленной с *group*; *group* по умолчанию равен нулю (означает всю сопоставленную подстроку). Возвращает `-1`, если *group* существует, но не участвовал в совпадении. Для объекта совпадения *m* и группы *g*, которая участвовала в совпадении, подстрока, сопоставленная группой *g* (эквивалент `m.group(g)`), – это11351136```python1137m.string[m.start(g):m.end(g)]1138```11391140Обратите внимание, что `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`](https://python-all.ru/3.2/library/exceptions.html#IndexError).11411142Пример, который удалит *remove\_this* из адресов электронной почты:11431144```python1145>>> email = "tony@tiremove_thisger.net"1146>>> m = re.search("remove_this", email)1147>>> email[:m.start()] + email[m.end():]1148'tony@tiger.net'1149```11501151#### `match.span([group])`11521153Для совпадения *m* возвращает кортеж из двух элементов `(m.start(group), m.end(group))`. Обратите внимание, что если *group* не участвовал в совпадении, результатом будет `(-1, -1)`. *group* по умолчанию равен нулю, то есть всё совпадение.11541155#### `match.pos`11561157Значение *pos*, которое было передано методу [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search) или [`match()`](https://python-all.ru/3.2/library/re.html#re.regex.match) объекта [*регулярного выражения*](https://python-all.ru/3.2/library/re.html#re-objects). Это индекс в строке, начиная с которого движок RE начал поиск совпадения.11581159#### `match.endpos`11601161Значение *endpos*, переданное методу [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search) или [`match()`](https://python-all.ru/3.2/library/re.html#re.regex.match) объекта [*регулярного выражения*](https://python-all.ru/3.2/library/re.html#re-objects). Это индекс в строке, за который движок регулярных выражений не выходит.11621163#### `match.lastindex`11641165Целочисленный индекс последней совпавшей захватывающей группы или `None`, если ни одна группа не совпала. Например, выражения `(a)b`, `((a)(b))` и `((ab))` будут иметь `lastindex == 1`, если применить к строке `'ab'`, а выражение `(a)(b)` будет иметь `lastindex == 2`, если применить к той же строке.11661167#### `match.lastgroup`11681169Имя последней совпавшей захватывающей группы или `None`, если у группы не было имени или если ни одна группа не совпала.11701171#### `match.re`11721173Объект регулярного выражения, метод [`match()`](https://python-all.ru/3.2/library/re.html#re.regex.match) или [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search) которого создал этот экземпляр совпадения.11741175#### `match.string`11761177Строка, переданная методу [`match()`](https://python-all.ru/3.2/library/re.html#re.regex.match) или [`search()`](https://python-all.ru/3.2/library/re.html#re.regex.search).11781179## 6.2.5. Примеры регулярных выражений11801181### 6.2.5.1. Проверка на пару11821183В этом примере используется следующая вспомогательная функция для более наглядного отображения объектов совпадения:11841185```python1186def displaymatch(match):1187 if match is None:1188 return None1189 return '<Match: %r, groups=%r>' % (match.group(), match.groups())1190```11911192Допустим, пишется программа для покера, где рука игрока представлена в виде строки из 5 символов, каждый символ обозначает карту: «a» – туз, «k» – король, «q» – дама, «j» – валет, «t» – десятка, а «2»–«9» – карты соответствующего достоинства.11931194Чтобы проверить, является ли заданная строка допустимой рукой, можно поступить следующим образом:11951196```python1197>>> valid = re.compile(r"^[a2-9tjqk]{5}$")1198>>> displaymatch(valid.match("akt5q")) # Допустимо.1199"<Match: 'akt5q', groups=()>"1200>>> displaymatch(valid.match("akt5e")) # Недопустимо.1201>>> displaymatch(valid.match("akt")) # Недопустимо.1202>>> displaymatch(valid.match("727ak")) # Допустимо.1203"<Match: '727ak', groups=()>"1204```12051206Та последняя рука, `"727ak"`, содержала пару, то есть две карты одного достоинства. Чтобы сопоставить это с помощью регулярного выражения, можно использовать обратные ссылки следующим образом:12071208```python1209>>> pair = re.compile(r".*(.).*\1")1210>>> displaymatch(pair.match("717ak")) # Пара семёрок.1211"<Match: '717', groups=('7',)>"1212>>> displaymatch(pair.match("718ak")) # Нет пар.1213>>> displaymatch(pair.match("354aa")) # Пара тузов.1214"<Match: '354aa', groups=('a',)>"1215```12161217Чтобы узнать, из какой карты состоит пара, можно использовать метод [`group()`](https://python-all.ru/3.2/library/re.html#re.match.group) объекта совпадения следующим образом:12181219```python1220>>> pair.match("717ak").group(1)1221'7'12221223# Error because re.match() returns None, which doesn't have a group() method:1224>>> pair.match("718ak").group(1)1225Traceback (most recent call last):1226 File "<pyshell#23>", line 1, in <module>1227 re.match(r".*(.).*\1", "718ak").group(1)1228AttributeError: 'NoneType' object has no attribute 'group'12291230>>> pair.match("354aa").group(1)1231'a'1232```12331234### 6.2.5.2. Имитация scanf()12351236В Python пока нет аналога `scanf()`. Регулярные выражения в целом мощнее, хотя и более многословны, чем строки форматирования `scanf()`. В таблице ниже приведены более или менее эквивалентные соответствия между токенами формата `scanf()` и регулярными выражениями.12371238| `scanf()` Токен | Регулярное выражение |1239| --- | --- |1240| `%c` | `.` |1241| `%5c` | `.{5}` |1242| `%d` | `[-+]?\d+` |1243| `%e`, `%E`, `%f`, `%g` | `[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?` |1244| `%i` | `[-+]?(0[xX][\dA-Fa-f]+\|0[0-7]*\|\d+)` |1245| `%o` | `[-+]?[0-7]+` |1246| `%s` | `\S+` |1247| `%u` | `\d+` |1248| `%x`, `%X` | `[-+]?(0[xX])?[\dA-Fa-f]+` |12491250Чтобы извлечь имя файла и числа из строки вида12511252```python1253/usr/sbin/sendmail - 0 errors, 4 warnings1254```12551256Можно использовать формат `scanf()`, например12571258```python1259%s - %d errors, %d warnings1260```12611262Эквивалентное регулярное выражение будет12631264```python1265(\S+) - (\d+) errors, (\d+) warnings1266```12671268### 6.2.5.3. Сравнение search() и match()12691270Python предлагает две разные базовые операции на основе регулярных выражений: [`re.match()`](https://python-all.ru/3.2/library/re.html#re.match) проверяет совпадение только в начале строки, а [`re.search()`](https://python-all.ru/3.2/library/re.html#re.search) проверяет совпадение в любом месте строки (именно так по умолчанию работает Perl).12711272Например:12731274```python1275>>> re.match("c", "abcdef") # Нет совпадения.1276>>> re.search("c", "abcdef") # Совпадает.1277<_sre.SRE_Match object at ...>1278```12791280Регулярные выражения, начинающиеся с `'^'`, можно использовать с [`search()`](https://python-all.ru/3.2/library/re.html#re.search), чтобы ограничить совпадение началом строки:12811282```python1283>>> re.match("c", "abcdef") # Нет совпадения.1284>>> re.search("^c", "abcdef") # Нет совпадения.1285>>> re.search("^a", "abcdef") # Совпадает.1286<_sre.SRE_Match object at ...>1287```12881289Однако обратите внимание, что в режиме [`MULTILINE`](https://python-all.ru/3.2/library/re.html#re.MULTILINE) [`match()`](https://python-all.ru/3.2/library/re.html#re.match) совпадает только в начале строки, тогда как [`search()`](https://python-all.ru/3.2/library/re.html#re.search) с регулярным выражением, начинающимся с `'^'`, будет находить совпадение в начале каждой строки.12901291```python1292>>> re.match('X', 'A\nB\nX', re.MULTILINE) # Нет совпадения.1293>>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Совпадает.1294<_sre.SRE_Match object at ...>1295```12961297### 6.2.5.4. Создание телефонной книги12981299[`split()`](https://python-all.ru/3.2/library/re.html#re.split) разбивает строку на список, используя переданный шаблон в качестве разделителя. Этот метод незаменим для преобразования текстовых данных в структуры данных, которые Python может легко читать и изменять, как показано в следующем примере, создающем телефонный справочник.13001301Сначала – входные данные. Обычно они берутся из файла, здесь мы используем синтаксис тройных кавычек:13021303```python1304>>> text = """Ross McFluff: 834.345.1254 155 Elm Street1305...1306... Ronald Heathmore: 892.345.3428 436 Finley Avenue1307... Frank Burger: 925.541.7625 662 South Dogwood Way1308...1309...1310... Heather Albrecht: 548.326.4584 919 Park Place"""1311```13121313Записи разделяются одним или несколькими символами новой строки. Теперь преобразуем строку в список, где каждая непустая строка будет отдельной записью:13141315```python1316>>> entries = re.split("\n+", text)1317>>> entries1318['Ross McFluff: 834.345.1254 155 Elm Street',1319'Ronald Heathmore: 892.345.3428 436 Finley Avenue',1320'Frank Burger: 925.541.7625 662 South Dogwood Way',1321'Heather Albrecht: 548.326.4584 919 Park Place']1322```13231324Наконец, каждая запись разбивается на список, содержащий имя, фамилию, номер телефона и адрес. Используется параметр `maxsplit` функции [`split()`](https://python-all.ru/3.2/library/re.html#re.split), потому что адрес содержит пробелы – наш разделитель:13251326```python1327>>> [re.split(":? ", entry, 3) for entry in entries]1328[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],1329['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],1330['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],1331['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]1332```13331334Шаблон `:?` соответствует двоеточию после фамилии, поэтому оно не попадает в результирующий список. С помощью `maxsplit`, равного `4`, можно отделить номер дома от названия улицы:13351336```python1337>>> [re.split(":? ", entry, 4) for entry in entries]1338[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],1339['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],1340['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],1341['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]1342```13431344### 6.2.5.5. Обработка текста13451346[`sub()`](https://python-all.ru/3.2/library/re.html#re.sub) заменяет каждое вхождение шаблона на строку или результат функции. В этом примере показано использование [`sub()`](https://python-all.ru/3.2/library/re.html#re.sub) с функцией для «изменения» (munge) текста, то есть перемешивания порядка всех символов в каждом слове предложения, кроме первого и последнего:13471348```python1349>>> def repl(m):1350... inner_word = list(m.group(2))1351... random.shuffle(inner_word)1352... return m.group(1) + "".join(inner_word) + m.group(3)1353>>> text = "Professor Abdolmalek, please report your absences promptly."1354>>> re.sub(r"(\w)(\w+)(\w)", repl, text)1355'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'1356>>> re.sub(r"(\w)(\w+)(\w)", repl, text)1357'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'1358```13591360### 6.2.5.6. Поиск всех наречий13611362[`findall()`](https://python-all.ru/3.2/library/re.html#re.findall) находит *все* вхождения шаблона, а не только первое, как [`search()`](https://python-all.ru/3.2/library/re.html#re.search). Например, если бы писателю потребовалось найти все наречия в тексте, он или она могли бы использовать [`findall()`](https://python-all.ru/3.2/library/re.html#re.findall) следующим образом:13631364```python1365>>> text = "He was carefully disguised but captured quickly by police."1366>>> re.findall(r"\w+ly", text)1367['carefully', 'quickly']1368```13691370### 6.2.5.7. Поиск всех наречий и их позиций13711372Если нужна более полная информация о всех совпадениях шаблона, чем просто текст совпадения, полезна функция [`finditer()`](https://python-all.ru/3.2/library/re.html#re.finditer), поскольку она возвращает [*объекты совпадений*](https://python-all.ru/3.2/library/re.html#match-objects), а не строки. Продолжая предыдущий пример: если бы писателю потребовалось найти все наречия *и их положения* в тексте, он или она мог бы использовать [`finditer()`](https://python-all.ru/3.2/library/re.html#re.finditer) следующим образом:13731374```python1375>>> text = "He was carefully disguised but captured quickly by police."1376>>> for m in re.finditer(r"\w+ly", text):1377... print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))137807-16: carefully137940-47: quickly1380```13811382### 6.2.5.8. Сырые строки13831384Сырые строки (`r"text"`) делают регулярные выражения читаемыми. Без них каждый обратный слеш (`'\'`) в регулярном выражении пришлось бы экранировать дополнительным слешем. Например, следующие две строки кода функционально идентичны:13851386```python1387>>> re.match(r"\W(.)\1\W", " ff ")1388<_sre.SRE_Match object at ...>1389>>> re.match("\\W(.)\\1\\W", " ff ")1390<_sre.SRE_Match object at ...>1391```13921393Если требуется сопоставить литеральный обратный слеш, его необходимо экранировать в регулярном выражении. В сырых строках это означает `r"\\"`. Без сырых строк придётся использовать `"\\\\"`, поэтому следующие строки кода функционально идентичны:13941395```python1396>>> re.match(r"\\", r"\\")1397<_sre.SRE_Match object at ...>1398>>> re.match("\\\\", r"\\")1399<_sre.SRE_Match object at ...>1400```14011402### 6.2.5.9. Написание токенизатора14031404[Токенизатор или сканер](https://python-all.ru/3.2/library/re.html) анализирует строку, чтобы разделить символы на группы. Это полезный первый шаг при написании компилятора или интерпретатора.14051406Категории текста задаются с помощью регулярных выражений. Метод заключается в том, чтобы объединить их в одно главное регулярное выражение и перебирать последовательные совпадения:14071408```python1409import collections1410import re14111412Token = collections.namedtuple('Token', ['typ', 'value', 'line', 'column'])14131414def tokenize(s):1415 keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}1416 token_specification = [1417 ('NUMBER', r'\d+(\.\d*)?'), # Целое или десятичное число.1418 ('ASSIGN', r':='), # Оператор присваивания.1419 ('END', r';'), # Терминатор инструкции.1420 ('ID', r'[A-Za-z]+'), # Идентификаторы.1421 ('OP', r'[+*\/\-]'), # Арифметические операторы.1422 ('NEWLINE', r'\n'), # Концы строк.1423 ('SKIP', r'[ \t]'), # Пропускать пробелы и табуляции.1424 ]1425 tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)1426 get_token = re.compile(tok_regex).match1427 line = 11428 pos = line_start = 01429 mo = get_token(s)1430 while mo is not None:1431 typ = mo.lastgroup1432 if typ == 'NEWLINE':1433 line_start = pos1434 line += 11435 elif typ != 'SKIP':1436 val = mo.group(typ)1437 if typ == 'ID' and val in keywords:1438 typ = val1439 yield Token(typ, val, line, mo.start()-line_start)1440 pos = mo.end()1441 mo = get_token(s, pos)1442 if pos != len(s):1443 raise RuntimeError('Unexpected character %r on line %d' %(s[pos], line))14441445statements = '''1446 IF quantity THEN1447 total := total + price * quantity;1448 tax := price * 0.05;1449 ENDIF;1450'''14511452for token in tokenize(statements):1453 print(token)1454```14551456Токенизатор выдаёт следующий результат:14571458```python1459Token(typ='IF', value='IF', line=2, column=5)1460Token(typ='ID', value='quantity', line=2, column=8)1461Token(typ='THEN', value='THEN', line=2, column=17)1462Token(typ='ID', value='total', line=3, column=9)1463Token(typ='ASSIGN', value=':=', line=3, column=15)1464Token(typ='ID', value='total', line=3, column=18)1465Token(typ='OP', value='+', line=3, column=24)1466Token(typ='ID', value='price', line=3, column=26)1467Token(typ='OP', value='*', line=3, column=32)1468Token(typ='ID', value='quantity', line=3, column=34)1469Token(typ='END', value=';', line=3, column=42)1470Token(typ='ID', value='tax', line=4, column=9)1471Token(typ='ASSIGN', value=':=', line=4, column=13)1472Token(typ='ID', value='price', line=4, column=16)1473Token(typ='OP', value='*', line=4, column=22)1474Token(typ='NUMBER', value='0.05', line=4, column=24)1475Token(typ='END', value=';', line=4, column=28)1476Token(typ='ENDIF', value='ENDIF', line=5, column=5)1477Token(typ='END', value=';', line=5, column=10)1478```1479