re.md
1> **Источник:** https://python-all.ru/3.3/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.3/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.3/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.3/howto/regex.html#regex-howto).3233Регулярные выражения могут содержать как специальные, так и обычные символы. Большинство обычных символов, например `'A'`, `'a'` или `'0'`, – это простейшие регулярные выражения: они просто соответствуют сами себе. Можно объединять обычные символы, так что `last` соответствует строке `'last'`. (В остальной части этого раздела мы будем записывать регулярные выражения `таким специальным стилем`, обычно без кавычек, а строки для поиска – `'в одинарных кавычках'`.)3435Некоторые символы, такие как `'|'` или `'('`, являются специальными. Специальные символы либо обозначают классы обычных символов, либо влияют на то, как интерпретируются окружающие их регулярные выражения. Строки паттернов регулярных выражений не могут содержать нулевые байты, но можно указать нулевой байт с помощью нотации `\number`, например `'\x00'`.3637Специальные символы:3839**`'.'`**4041(Точка.) В режиме по умолчанию соответствует любому символу, кроме перевода строки. Если указан флаг4243[`DOTALL`](https://python-all.ru/3.3/library/re.html#re.DOTALL)4445, соответствует любому символу, включая перевод строки.4647**`'^'`**4849(Циркумфлекс.) Соответствует началу строки, а в режиме5051[`MULTILINE`](https://python-all.ru/3.3/library/re.html#re.MULTILINE)5253также соответствует позиции сразу после каждого перевода строки.5455**`'$'`**5657Соответствует концу строки или позиции перед символом новой строки в конце строки, а в режиме5859[`MULTILINE`](https://python-all.ru/3.3/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.3/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.3/library/re.html#re.ASCII) или [`LOCALE`](https://python-all.ru/3.3/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.3/library/re.html#re.A) (только ASCII), [`re.I`](https://python-all.ru/3.3/library/re.html#re.I) (игнорировать регистр), [`re.L`](https://python-all.ru/3.3/library/re.html#re.L) (зависит от локали), [`re.M`](https://python-all.ru/3.3/library/re.html#re.M) (многострочный), [`re.S`](https://python-all.ru/3.3/library/re.html#re.S) (точка соответствует всему) и [`re.X`](https://python-all.ru/3.3/library/re.html#re.X) (подробный) для всего регулярного выражения. (Флаги описаны в разделе [*Содержание модуля*](https://python-all.ru/3.3/library/re.html#contents-of-module-re).) Это полезно, если нужно включить флаги в состав регулярного выражения, а не передавать аргумент *flag* в функцию [`re.compile()`](https://python-all.ru/3.3/library/re.html#re.compile).373374Обратите внимание, что флаг `(?x)` изменяет способ разбора выражения. Он должен быть указан первым в строке выражения или после одного или нескольких пробельных символов. Если перед флагом есть непробельные символы, результат не определён.375376**`(?:...)`**377378Незапоминающая версия обычных круглых скобок. Совпадает с любым регулярным выражением внутри скобок, но подстрока, совпавшая с группой,379380*не может*381382быть извлечена после выполнения сопоставления или использована для ссылки позже в шаблоне.383384**`(?P<name>...)`**385386Аналогично обычным круглым скобкам, но подстрока, совпавшая с группой, доступна по символическому имени группы *name*. Имена групп должны быть допустимыми идентификаторами Python, и каждое имя группы должно быть определено только один раз в регулярном выражении. Символическая группа также является нумерованной группой, как если бы группа не была именованной.387388Именованные группы можно использовать в трёх контекстах. Если паттерн имеет вид `(?P<quote>['"]).*?(?P=quote)` (т.е. соответствует строке, заключённой в одинарные или двойные кавычки):389390| Контекст ссылки на группу «quote» | Способы ссылки на нее |391| --- | --- |392| в том же самом шаблоне | `(?P=quote)` (как показано) `\1` |393| при обработке объекта сопоставления `m` | `m.group('quote')` `m.end('quote')` (и т.д.) |394| в строке, передаваемой в аргумент `repl` функции `re.sub()` | `\g<quote>` `\g<1>` `\1` |395396**`(?P=name)`**397398Обратная ссылка на именованную группу; соответствует любому тексту, который был найден ранее группой с именем399400*name*401402.403404**`(?#...)`**405406Комментарий; содержимое скобок просто игнорируется.407408**`(?=...)`**409410Совпадает, если411412`...`413414совпадает далее, но не поглощает ни одного символа строки. Это называется опережающей проверкой. Например,415416`Isaac (?=Asimov)`417418совпадёт с419420`'Isaac '`421422только если за ним следует423424`'Asimov'`425426.427428**`(?!...)`**429430Совпадает, если431432`...`433434не совпадает далее. Это отрицательная опережающая проверка. Например,435436`Isaac (?!Asimov)`437438совпадёт с439440`'Isaac '`441442только если за ним443444*не*445446следует447448`'Asimov'`449450.451452**`(?<=...)`**453454Совпадает, если текущей позиции в строке предшествует совпадение с `...`, которое заканчивается в текущей позиции. Это называется *положительной ретроспективной проверкой (positive lookbehind assertion)*. `(?<=abc)def` найдёт совпадение в `abcdef`, поскольку ретроспективная проверка отступит на 3 символа и проверит, совпадает ли содержащийся шаблон. Содержащийся шаблон должен соответствовать строкам только фиксированной длины, то есть `abc` или `a|b` разрешены, но `a*` и `a{3,4}` – нет. Обратите внимание, что шаблоны, начинающиеся с положительных ретроспективных проверок, не будут совпадать в начале искомой строки; скорее всего, следует использовать функцию [`search()`](https://python-all.ru/3.3/library/re.html#re.search), а не [`match()`](https://python-all.ru/3.3/library/re.html#re.match):455456```python457>>> import re458>>> m = re.search('(?<=abc)def', 'abcdef')459>>> m.group(0)460'def'461```462463Этот пример ищет слово, следующее за дефисом:464465```python466>>> m = re.search('(?<=-)\w+', 'spam-egg')467>>> m.group(0)468'egg'469```470471**`(?<!...)`**472473Совпадает, если текущей позиции в строке не предшествует совпадение с474475`...`476477. Это называется478479*отрицательной ретроспективной проверкой*480481. Аналогично положительным ретроспективным проверкам, вложенный шаблон может соответствовать только строкам фиксированной длины. Шаблоны, начинающиеся с отрицательной ретроспективной проверки, могут совпадать в начале искомой строки.482483**`(?(id/name)yes-pattern|no-pattern)`**484485Пытается применить486487`yes-pattern`488489, если группа с указанным490491*id*492493или494495*name*496497существует, и498499`no-pattern`500501– если нет.502503`no-pattern`504505необязателен и может быть опущен. Например,506507`(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$)`508509– это неудачный шаблон для проверки email, который совпадёт с510511`'<user@host.com>'`512513, а также с514515`'user@host.com'`516517, но не с518519`'<user@host.com'`520521и не с522523`'user@host.com>'`524525.526527Специальные последовательности состоят из `'\'` и символа из списка ниже. Если обычный символ отсутствует в списке, то результирующее РВ будет соответствовать второму символу. Например, `\$` соответствует символу `'$'`.528529**`\number`**530531Совпадает с содержимым группы с тем же номером. Группы нумеруются, начиная с 1. Например,532533`(.+) \1`534535совпадает с536537`'the 'the'`538539или540541`'55 55'`542543, но не с544545`'thethe'`546547(обратите внимание на пробел после группы). Эта специальная последовательность может использоваться только для совпадения с одной из первых 99 групп. Если первая цифра548549*числа*550551равна 0, или552553*число*554555состоит из 3 восьмеричных цифр, это будет интерпретироваться не как ссылка на группу, а как символ с восьмеричным значением556557*числа*558559. Внутри560561`'['`562563и564565`']'`566567класса символов все числовые escape-последовательности рассматриваются как символы.568569**`\A`**570571Совпадает только в начале строки.572573**`\b`**574575Совпадает с пустой строкой, но только в начале или конце слова. Слово определяется как последовательность буквенно-цифровых символов Unicode или символа подчёркивания, поэтому конец слова обозначается пробелом или не буквенно-цифровым символом Unicode, не являющимся подчёркиванием. Обратите внимание, что формально `\b` определяется как граница между символом `\w` и символом `\W` (или наоборот), или между `\w` и началом/концом строки. Это означает, что `r'\bfoo\b'` совпадает с `'foo'`, `'foo.'`, `'(foo)'`, `'bar foo baz'`, но не с `'foobar'` или `'foo3'`.576577По умолчанию используются буквенно-цифровые символы Unicode, но это можно изменить с помощью флага [`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII). Внутри диапазона символов `\b` представляет символ backspace для совместимости со строковыми литералами Python.578579**`\B`**580581Совпадает с пустой строкой, но только когда она582583*не*584585находится в начале или конце слова. Это означает, что586587`r'py\B'`588589совпадает с590591`'python'`592593,594595`'py3'`596597,598599`'py2'`600601, но не с602603`'py'`604605,606607`'py.'`608609или610611`'py!'`612613.614615`\B`616617является противоположностью618619`\b`620621, поэтому символами слова являются буквенно-цифровые символы Unicode или подчёркивание, хотя это можно изменить с помощью флага622623[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)624625.626627**`\d`**628629**Для шаблонов Unicode (str):**630631Совпадает с любой десятичной цифрой Unicode (то есть любым символом из категории Unicode \[Nd\]). Сюда входит632633`[0-9]`634635, а также многие другие цифровые символы. Если используется флаг636637[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)638639, совпадает только640641`[0-9]`642643(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное644645`[0-9]`646647).648649**Для 8-битных (байтовых) шаблонов:**650651Соответствует любой десятичной цифре; это эквивалентно652653`[0-9]`654655.656657**`\D`**658659Совпадает с любым символом, не являющимся десятичной цифрой Unicode. Это противоположность660661`\d`662663. Если используется флаг664665[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)666667, это становится эквивалентом668669`[^0-9]`670671(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное672673`[^0-9]`674675).676677**`\s`**678679**Для шаблонов Unicode (str):**680681Совпадает с пробельными символами Unicode (к которым относятся682683`[ \t\n\r\f\v]`684685, а также многие другие символы, например неразрывные пробелы, требуемые правилами типографики во многих языках). Если используется флаг686687[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)688689, совпадает только690691`[ \t\n\r\f\v]`692693(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное694695`[ \t\n\r\f\v]`696697).698699**Для 8-битных (байтовых) шаблонов:**700701Совпадает с символами, считающимися пробельными в наборе символов ASCII; это эквивалентно702703`[ \t\n\r\f\v]`704705.706707**`\S`**708709Совпадает с любым символом, не являющимся пробельным символом Unicode. Это противоположность710711`\s`712713. Если используется флаг714715[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)716717, это становится эквивалентом718719`[^ \t\n\r\f\v]`720721(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное722723`[^ \t\n\r\f\v]`724725).726727**`\w`**728729**Для шаблонов Unicode (str):**730731Совпадает с символами слова Unicode; сюда входят большинство символов, которые могут быть частью слова в любом языке, а также цифры и символ подчёркивания. Если используется флаг732733[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)734735, совпадает только736737`[a-zA-Z0-9_]`738739(но флаг влияет на всё регулярное выражение, поэтому в таких случаях лучше использовать явное740741`[a-zA-Z0-9_]`742743).744745**Для 8-битных (байтовых) шаблонов:**746747Совпадает с символами, считающимися буквенно-цифровыми в наборе символов ASCII; это эквивалентно748749`[a-zA-Z0-9_]`750751.752753**`\W`**754755Соответствует любому символу, который не является символом слова Unicode. Это противоположность756757`\w`758759. Если используется флаг760761[`ASCII`](https://python-all.ru/3.3/library/re.html#re.ASCII)762763, это становится эквивалентом764765`[^a-zA-Z0-9_]`766767(но флаг влияет на всё регулярное выражение, поэтому в таких случаях использование явного768769`[^a-zA-Z0-9_]`770771может быть лучшим выбором).772773**`\Z`**774775Совпадение только в конце строки.776777Большинство стандартных управляющих последовательностей, поддерживаемых строковыми литералами Python, также принимаются синтаксическим анализатором регулярных выражений:778779```python780\a \b \f \n781\r \t \u \U782\v \x \\783```784785(Обратите внимание, что `\b` используется для обозначения границ слов и означает “backspace” только внутри символьных классов.)786787Управляющие последовательности `'\u'` и `'\U'` распознаются только в шаблонах Unicode. В байтовых шаблонах они не обрабатываются особым образом.788789Восьмеричные управляющие последовательности поддерживаются в ограниченной форме. Если первая цифра – 0, или если есть три восьмеричных цифры, это считается восьмеричной управляющей последовательностью. В противном случае это ссылка на группу. Как и в строковых литералах, восьмеричные управляющие последовательности всегда имеют длину не более трёх цифр.790791Изменено в версии 3.3: Добавлены управляющие последовательности `'\u'` и `'\U'`.792793## 6.2.2. Содержимое модуля794795Модуль определяет несколько функций, констант и одно исключение. Некоторые из функций являются упрощёнными версиями полнофункциональных методов для скомпилированных регулярных выражений. В большинстве нетривиальных приложений всегда используется скомпилированная форма.796797#### `re.compile(pattern, flags=0)`798799Компилирует шаблон регулярного выражения в объект регулярного выражения, который можно использовать для поиска совпадений с помощью его методов [`match()`](https://python-all.ru/3.3/library/re.html#re.match) и [`search()`](https://python-all.ru/3.3/library/re.html#re.search), описанных ниже.800801Поведение выражения можно изменить, указав значение *flags*. В качестве значений можно использовать любые из следующих переменных, комбинируя их с помощью побитового ИЛИ (оператор `|`).802803Последовательность804805```python806prog = re.compile(pattern)807result = prog.match(string)808```809810эквивалентна811812```python813result = re.match(pattern, string)814```815816но использование [`re.compile()`](https://python-all.ru/3.3/library/re.html#re.compile) и сохранение полученного объекта регулярного выражения для повторного использования более эффективно, когда выражение будет использоваться несколько раз в одной программе.817818> **Примечание**819>820> Скомпилированные версии последних шаблонов, переданных в [`re.match()`](https://python-all.ru/3.3/library/re.html#re.match), [`re.search()`](https://python-all.ru/3.3/library/re.html#re.search) или [`re.compile()`](https://python-all.ru/3.3/library/re.html#re.compile), кэшируются, поэтому программам, использующим лишь несколько регулярных выражений за раз, не нужно беспокоиться о компиляции регулярных выражений.821822#### `re.A`823824#### `re.ASCII`825826Заставляет `\w`, `\W`, `\b`, `\B`, `\d`, `\D`, `\s` и `\S` выполнять сопоставление только из ASCII вместо полного сопоставления Unicode. Это имеет смысл только для шаблонов Unicode и игнорируется для байтовых шаблонов.827828Обратите внимание, что для обратной совместимости флаг `re.U` всё ещё существует (как и его синоним `re.UNICODE` и его встроенный аналог `(?u)`), но они избыточны в Python 3, так как сопоставление по умолчанию для строк выполняется с Unicode (а сопоставление Unicode не допускается для байтов).829830#### `re.DEBUG`831832Отображает отладочную информацию о скомпилированном выражении.833834#### `re.I`835836#### `re.IGNORECASE`837838Выполняет сопоставление без учёта регистра; выражения вроде `[A-Z]` будут соответствовать также и строчным буквам. На это не влияет текущая локаль, и оно работает с символами Unicode так, как и ожидается.839840#### `re.L`841842#### `re.LOCALE`843844Заставляет `\w`, `\W`, `\b`, `\B`, `\s` и `\S` зависеть от текущей локали. Использование этого флага не рекомендуется, так как механизм локали очень ненадёжен и в любом случае обрабатывает только одну «культуру» за раз; вместо этого следует использовать сопоставление Unicode, которое является стандартным в Python 3 для шаблонов Unicode (str).845846#### `re.M`847848#### `re.MULTILINE`849850При указании этого флага символ шаблона `'^'` совпадает с началом строки и с началом каждой строки (сразу после каждого перевода строки); а символ шаблона `'$'` совпадает с концом строки и с концом каждой строки (непосредственно перед каждым переводом строки). По умолчанию `'^'` совпадает только с началом строки, а `'$'` – только с концом строки и непосредственно перед переводом строки (если он есть) в конце строки.851852#### `re.S`853854#### `re.DOTALL`855856Заставляет специальный символ `'.'` совпадать с любым символом, включая перевод строки; без этого флага `'.'` будет совпадать с любым символом, *кроме* перевода строки.857858#### `re.X`859860#### `re.VERBOSE`861862Этот флаг позволяет писать более читаемые регулярные выражения. Пробельные символы в шаблоне игнорируются, кроме случаев, когда они находятся внутри символьного класса или перед ними стоит неэкранированная обратная косая черта. Кроме того, если строка содержит `'#'`, не находящийся в символьном классе и не предварённый неэкранированной обратной косой чертой, все символы от самого левого такого `'#'` до конца строки игнорируются.863864Это означает, что следующие два объекта регулярных выражений, которые соответствуют десятичному числу, функционально эквивалентны:865866```python867a = re.compile(r"""\d + # the integral part868 \. # the decimal point869 \d * # some fractional digits""", re.X)870b = re.compile(r"\d+\.\d*")871```872873#### `re.search(pattern, string, flags=0)`874875Просматривает *string* в поисках позиции, где регулярное выражение *pattern* даёт совпадение, и возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.3/library/re.html#match-objects). Возвращает `None`, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от поиска совпадения нулевой длины в какой-либо точке строки.876877#### `re.match(pattern, string, flags=0)`878879Если ноль или более символов в начале *string* соответствуют регулярному выражению *pattern*, возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.3/library/re.html#match-objects). Возвращает `None`, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.880881Обратите внимание, что даже в режиме [`MULTILINE`](https://python-all.ru/3.3/library/re.html#re.MULTILINE) функция [`re.match()`](https://python-all.ru/3.3/library/re.html#re.match) находит совпадение только в начале строки, а не в начале каждой строки.882883Если нужно найти совпадение в любом месте *string*, используйте [`search()`](https://python-all.ru/3.3/library/re.html#re.search) (см. также [*search() vs. match()*](https://python-all.ru/3.3/library/re.html#search-vs-match)).884885#### `re.split(pattern, string, maxsplit=0, flags=0)`886887Разделяет *string* по вхождениям *pattern*. Если в *pattern* используются захватывающие круглые скобки, то текст всех групп в шаблоне также возвращается как часть результирующего списка. Если *maxsplit* не равно нулю, то происходит не более *maxsplit* разбиений, а остаток строки возвращается как последний элемент списка.888889```python890>>> re.split('\W+', 'Words, words, words.')891['Words', 'words', 'words', '']892>>> re.split('(\W+)', 'Words, words, words.')893['Words', ', ', 'words', ', ', 'words', '.', '']894>>> re.split('\W+', 'Words, words, words.', 1)895['Words', 'words, words.']896>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)897['0', '3', '9']898```899900Если в разделителе есть захватывающие группы и он совпадает в начале строки, результат будет начинаться с пустой строки. То же самое относится и к концу строки:901902```python903>>> re.split('(\W+)', '...words, words...')904['', '...', 'words', ', ', 'words', '...', '']905```906907Таким образом, компоненты разделителя всегда находятся на одних и тех же относительных индексах в результирующем списке.908909Обратите внимание, что *split* никогда не разделяет строку по пустому совпадению шаблона. Например:910911```python912>>> re.split('x*', 'foo')913['foo']914>>> re.split("(?m)^$", "foo\n\nbar\n")915['foo\n\nbar\n']916```917918Изменено в версии 3.1: Добавлен необязательный аргумент flags.919920#### `re.findall(pattern, string, flags=0)`921922Возвращает все непересекающиеся совпадения *pattern* в *string*, в виде списка строк. Строка *string* сканируется слева направо, совпадения возвращаются в порядке обнаружения. Если в шаблоне присутствуют одна или несколько групп, возвращается список групп; если групп больше одной – список кортежей. Пустые совпадения включаются в результат, кроме случаев, когда они примыкают к началу другого совпадения.923924#### `re.finditer(pattern, string, flags=0)`925926Возвращает [*итератор*](https://python-all.ru/3.3/glossary.html#term-iterator), выдающий [*объекты совпадений*](https://python-all.ru/3.3/library/re.html#match-objects) по всем непересекающимся совпадениям регулярного выражения *pattern* в *string*. Строка *string* сканируется слева направо, совпадения возвращаются в порядке обнаружения. Пустые совпадения включаются в результат, кроме случаев, когда они примыкают к началу другого совпадения.927928#### `re.sub(pattern, repl, string, count=0, flags=0)`929930Возвращает строку, полученную заменой крайних левых непересекающихся вхождений *pattern* в *string* на замену *repl*. Если шаблон не найден, возвращается *string* без изменений. *repl* может быть строкой или функцией; если это строка, все обратные слеши в ней обрабатываются. То есть `\n` преобразуется в символ новой строки, `\r` – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как `\j`, остаются без изменений. Обратные ссылки, такие как `\6`, заменяются подстрокой, соответствующей группе 6 в шаблоне. Например:931932```python933>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',934... r'static PyObject*\npy_\1(void)\n{',935... 'def myfunc():')936'static PyObject*\npy_myfunc(void)\n{'937```938939Если *repl* – функция, она вызывается для каждого непересекающегося вхождения *pattern*. Функция принимает один аргумент – объект совпадения – и возвращает строку замены. Например:940941```python942>>> def dashrepl(matchobj):943... if matchobj.group(0) == '-': return ' '944... else: return '-'945>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')946'pro--gram files'947>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)948'Baked Beans & Spam'949```950951Шаблон может быть строкой или объектом RE.952953Необязательный аргумент *count* – это максимальное количество заменяемых вхождений шаблона; *count* должен быть неотрицательным целым числом. Если опущено или равно нулю, заменяются все вхождения. Пустые совпадения шаблона заменяются только тогда, когда они не примыкают к предыдущему совпадению, поэтому `sub('x*', '-', 'abc')` возвращает `'-a-b-c-'`.954955В строковых аргументах *repl*, помимо escape-последовательностей символов и обратных ссылок, описанных выше, `\g<name>` использует подстроку, соответствующую группе с именем `name`, как определено синтаксисом `(?P<name>...)`. `\g<number>` использует соответствующий номер группы; `\g<2>` поэтому эквивалентно `\2`, но не является неоднозначным в замене такой как `\g<2>0`. `\20` было бы интерпретировано как ссылка на группу 20, а не как ссылка на группу 2, за которой следует литеральный символ `'0'`. Обратная ссылка `\g<0>` заменяет всей подстрокой, соответствующей регулярному выражению.956957Изменено в версии 3.1: Добавлен необязательный аргумент flags.958959#### `re.subn(pattern, repl, string, count=0, flags=0)`960961Выполняет ту же операцию, что и [`sub()`](https://python-all.ru/3.3/library/re.html#re.sub), но возвращает кортеж `(new_string, number_of_subs_made)`.962963Изменено в версии 3.1: Добавлен необязательный аргумент flags.964965#### `re.escape(string)`966967Экранирует все символы в шаблоне, кроме букв ASCII, цифр и `'_'`. Это полезно, если нужно сопоставить произвольную литеральную строку, которая может содержать метасимволы регулярных выражений.968969Изменено в версии 3.3: Символ `'_'` больше не экранируется.970971#### `re.purge()`972973Очищает кэш регулярных выражений.974975#### `exception re.error`976977Исключение возникает, когда строка, переданная одной из функций здесь, не является допустимым регулярным выражением (например, может содержать непарные скобки) или когда происходит другая ошибка во время компиляции или сопоставления. Это никогда не является ошибкой, если строка не содержит совпадений с шаблоном.978979## 6.2.3. Объекты регулярных выражений980981Скомпилированные объекты регулярных выражений поддерживают следующие методы и атрибуты:982983#### `regex.search(string[, pos[, endpos]])`984985Просматривает *string* в поиске позиции, где это регулярное выражение даёт совпадение, и возвращает соответствующий [*объект совпадения*](https://python-all.ru/3.3/library/re.html#match-objects). Возвращает `None`, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от нахождения совпадения нулевой длины в какой-то точке строки.986987Необязательный второй параметр *pos* задаёт индекс в строке, с которого начинается поиск; по умолчанию `0`. Это не полностью эквивалентно срезу строки; символ шаблона `'^'` сопоставляется с реальным началом строки и с позициями сразу после символа новой строки, но не обязательно с индексом, с которого должен начинаться поиск.988989Необязательный параметр *endpos* ограничивает, насколько далеко будет просматриваться строка; это будет так, как если бы строка имела длину *endpos* символов, поэтому для поиска совпадения будут просматриваться только символы от *pos* до `endpos - 1`. Если *endpos* меньше *pos*, совпадение не будет найдено; в противном случае, если *rx* – скомпилированный объект регулярного выражения, `rx.search(string, 0, 50)` эквивалентно `rx.search(string[:50], 0)`.990991```python992>>> pattern = re.compile("d")993>>> pattern.search("dog") # Совпадение на индексе 0994<_sre.SRE_Match object at ...>995>>> pattern.search("dog", 1) # Совпадения нет; поиск не включает "d"996```997998#### `regex.match(string[, pos[, endpos]])`9991000Если ноль или более символов в *начале* *string* соответствуют этому регулярному выражению, возвращается соответствующий [*объект совпадения*](https://python-all.ru/3.3/library/re.html#match-objects). Возвращается `None`, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.10011002Необязательные параметры *pos* и *endpos* имеют тот же смысл, что и для метода [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search).10031004```python1005>>> pattern = re.compile("o")1006>>> pattern.match("dog") # Совпадения нет, так как "o" не в начале строки "dog".1007>>> pattern.match("dog", 1) # Совпадение есть, так как "o" – второй символ строки "dog".1008<_sre.SRE_Match object at ...>1009```10101011Чтобы найти совпадение в любом месте *string*, используйте [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search) (см. также [*search() vs. match()*](https://python-all.ru/3.3/library/re.html#search-vs-match)).10121013#### `regex.split(string, maxsplit=0)`10141015Идентично функции [`split()`](https://python-all.ru/3.3/library/re.html#re.split), используя скомпилированный шаблон.10161017#### `regex.findall(string[, pos[, endpos]])`10181019Аналогично функции [`findall()`](https://python-all.ru/3.3/library/re.html#re.findall), использующей скомпилированный шаблон, но также принимает необязательные параметры *pos* и *endpos*, ограничивающие область поиска, как в [`match()`](https://python-all.ru/3.3/library/re.html#re.match).10201021#### `regex.finditer(string[, pos[, endpos]])`10221023Аналогично функции [`finditer()`](https://python-all.ru/3.3/library/re.html#re.finditer), использующей скомпилированный шаблон, но также принимает необязательные параметры *pos* и *endpos*, ограничивающие область поиска, как в [`match()`](https://python-all.ru/3.3/library/re.html#re.match).10241025#### `regex.sub(repl, string, count=0)`10261027Идентична функции [`sub()`](https://python-all.ru/3.3/library/re.html#re.sub), использующей скомпилированный шаблон.10281029#### `regex.subn(repl, string, count=0)`10301031Идентична функции [`subn()`](https://python-all.ru/3.3/library/re.html#re.subn), использующей скомпилированный шаблон.10321033#### `regex.flags`10341035Флаги сопоставления регулярного выражения. Это комбинация флагов, переданных в [`compile()`](https://python-all.ru/3.3/library/re.html#re.compile), любых `(?...)` встроенных флагов в шаблоне и неявных флагов, таких как `UNICODE`, если шаблон является строкой Unicode.10361037#### `regex.groups`10381039Количество захватываемых групп в шаблоне.10401041#### `regex.groupindex`10421043Словарь, сопоставляющий любые символьные имена групп, определённые с помощью `(?P<id>)`, с номерами групп. Словарь пуст, если в шаблоне не использовались символьные группы.10441045#### `regex.pattern`10461047Строка шаблона, из которой был скомпилирован объект RE.10481049## 6.2.4. Объекты совпадений10501051Объекты совпадения всегда имеют логическое значение `True`. Поскольку [`match()`](https://python-all.ru/3.3/library/re.html#re.regex.match) и [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search) возвращают `None`, когда совпадения нет, можно проверить наличие совпадения с помощью простого оператора `if`:10521053```python1054match = re.search(pattern, string)1055if match:1056 process(match)1057```10581059Объекты сопоставления поддерживают следующие методы и атрибуты:10601061#### `match.expand(template)`10621063Возвращает строку, полученную в результате замены обратной косой черты в шаблоне строки *template*, как это делает метод [`sub()`](https://python-all.ru/3.3/library/re.html#re.regex.sub). Экранированные последовательности, такие как `\n`, преобразуются в соответствующие символы, а числовые обратные ссылки (`\1`, `\2`) и именованные обратные ссылки (`\g<1>`, `\g<name>`) заменяются содержимым соответствующей группы.10641065#### `match.group([group1, ...])`10661067Возвращает одну или несколько подгрупп совпадения. Если аргумент один, результатом является одна строка; если аргументов несколько, результат – кортеж с одним элементом на каждый аргумент. Без аргументов *group1* по умолчанию равен нулю (возвращается всё совпадение). Если аргумент *groupN* равен нулю, соответствующее возвращаемое значение – вся сопоставленная строка; если он находится в диапазоне \[1..99\] включительно, это строка, соответствующая соответствующей группе в скобках. Если номер группы отрицателен или больше количества групп, определённых в шаблоне, возбуждается исключение [`IndexError`](https://python-all.ru/3.3/library/exceptions.html#IndexError). Если группа содержится в части шаблона, которая не совпала, соответствующий результат равен `None`. Если группа содержится в части шаблона, которая совпала несколько раз, возвращается последнее совпадение.10681069```python1070>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")1071>>> m.group(0) # Всё совпадение1072'Isaac Newton'1073>>> m.group(1) # Первая группа в скобках.1074'Isaac'1075>>> m.group(2) # Вторая группа в скобках.1076'Newton'1077>>> m.group(1, 2) # Несколько аргументов дают кортеж.1078('Isaac', 'Newton')1079```10801081Если в регулярном выражении используется синтаксис `(?P<name>...)`, то аргументы *groupN* могут также быть строками, идентифицирующими группы по их имени. Если строковый аргумент не используется как имя группы в шаблоне, возбуждается исключение [`IndexError`](https://python-all.ru/3.3/library/exceptions.html#IndexError).10821083Довольно сложный пример:10841085```python1086>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")1087>>> m.group('first_name')1088'Malcolm'1089>>> m.group('last_name')1090'Reynolds'1091```10921093Именованные группы также можно указывать по их индексу:10941095```python1096>>> m.group(1)1097'Malcolm'1098>>> m.group(2)1099'Reynolds'1100```11011102Если группа совпадает несколько раз, доступно только последнее совпадение:11031104```python1105>>> m = re.match(r"(..)+", "a1b2c3") # Совпадает 3 раза.1106>>> m.group(1) # Возвращает только последнее совпадение.1107'c3'1108```11091110#### `match.groups(default=None)`11111112Возвращает кортеж, содержащий все подгруппы совпадения, от 1 до количества групп в шаблоне. Аргумент *default* используется для групп, которые не участвовали в совпадении; по умолчанию он равен `None`.11131114Например:11151116```python1117>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")1118>>> m.groups()1119('24', '1632')1120```11211122Если сделать десятичную точку и всё после неё необязательными, не все группы могут участвовать в совпадении. Эти группы по умолчанию будут равны `None`, если не указан аргумент *default*:11231124```python1125>>> m = re.match(r"(\d+)\.?(\d+)?", "24")1126>>> m.groups() # Вторая группа по умолчанию – None.1127('24', None)1128>>> m.groups('0') # Теперь вторая группа по умолчанию – '0'.1129('24', '0')1130```11311132#### `match.groupdict(default=None)`11331134Возвращает словарь, содержащий все *именованные* подгруппы совпадения, где ключом является имя подгруппы. Аргумент *default* используется для групп, которые не участвовали в совпадении; по умолчанию он равен `None`. Например:11351136```python1137>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")1138>>> m.groupdict()1139{'first_name': 'Malcolm', 'last_name': 'Reynolds'}1140```11411142#### `match.start([group])`11431144#### `match.end([group])`11451146Возвращает индексы начала и конца подстроки, сопоставленной с *group*; *group* по умолчанию равен нулю (означает всю сопоставленную подстроку). Возвращает `-1`, если *group* существует, но не участвовал в совпадении. Для объекта совпадения *m* и группы *g*, которая участвовала в совпадении, подстрока, сопоставленная группой *g* (эквивалент `m.group(g)`), – это11471148```python1149m.string[m.start(g):m.end(g)]1150```11511152Обратите внимание, что `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.3/library/exceptions.html#IndexError).11531154Пример, который удалит *remove\_this* из адресов электронной почты:11551156```python1157>>> email = "tony@tiremove_thisger.net"1158>>> m = re.search("remove_this", email)1159>>> email[:m.start()] + email[m.end():]1160'tony@tiger.net'1161```11621163#### `match.span([group])`11641165Для совпадения *m* возвращает кортеж из двух элементов `(m.start(group), m.end(group))`. Обратите внимание, что если *group* не участвовал в совпадении, результатом будет `(-1, -1)`. *group* по умолчанию равен нулю, то есть всё совпадение.11661167#### `match.pos`11681169Значение *pos*, которое было передано методу [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search) или [`match()`](https://python-all.ru/3.3/library/re.html#re.regex.match) объекта [*регулярного выражения*](https://python-all.ru/3.3/library/re.html#re-objects). Это индекс в строке, начиная с которого движок RE начал поиск совпадения.11701171#### `match.endpos`11721173Значение *endpos*, переданное методу [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search) или [`match()`](https://python-all.ru/3.3/library/re.html#re.regex.match) объекта [*регулярного выражения*](https://python-all.ru/3.3/library/re.html#re-objects). Это индекс в строке, за который движок регулярных выражений не выходит.11741175#### `match.lastindex`11761177Целочисленный индекс последней совпавшей захватывающей группы или `None`, если ни одна группа не совпала. Например, выражения `(a)b`, `((a)(b))` и `((ab))` будут иметь `lastindex == 1`, если применить к строке `'ab'`, а выражение `(a)(b)` будет иметь `lastindex == 2`, если применить к той же строке.11781179#### `match.lastgroup`11801181Имя последней совпавшей захватывающей группы или `None`, если у группы не было имени или если ни одна группа не совпала.11821183#### `match.re`11841185Объект регулярного выражения, метод [`match()`](https://python-all.ru/3.3/library/re.html#re.regex.match) или [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search) которого создал этот экземпляр совпадения.11861187#### `match.string`11881189Строка, переданная методу [`match()`](https://python-all.ru/3.3/library/re.html#re.regex.match) или [`search()`](https://python-all.ru/3.3/library/re.html#re.regex.search).11901191## 6.2.5. Примеры регулярных выражений11921193### 6.2.5.1. Проверка на пару11941195В этом примере используется следующая вспомогательная функция для более наглядного отображения объектов совпадения:11961197```python1198def displaymatch(match):1199 if match is None:1200 return None1201 return '<Match: %r, groups=%r>' % (match.group(), match.groups())1202```12031204Допустим, пишется программа для покера, где рука игрока представлена в виде строки из 5 символов, каждый символ обозначает карту: «a» – туз, «k» – король, «q» – дама, «j» – валет, «t» – десятка, а «2»–«9» – карты соответствующего достоинства.12051206Чтобы проверить, является ли заданная строка допустимой рукой, можно поступить следующим образом:12071208```python1209>>> valid = re.compile(r"^[a2-9tjqk]{5}$")1210>>> displaymatch(valid.match("akt5q")) # Допустимо.1211"<Match: 'akt5q', groups=()>"1212>>> displaymatch(valid.match("akt5e")) # Недопустимо.1213>>> displaymatch(valid.match("akt")) # Недопустимо.1214>>> displaymatch(valid.match("727ak")) # Допустимо.1215"<Match: '727ak', groups=()>"1216```12171218Та последняя рука, `"727ak"`, содержала пару, то есть две карты одного достоинства. Чтобы сопоставить это с помощью регулярного выражения, можно использовать обратные ссылки следующим образом:12191220```python1221>>> pair = re.compile(r".*(.).*\1")1222>>> displaymatch(pair.match("717ak")) # Пара семёрок.1223"<Match: '717', groups=('7',)>"1224>>> displaymatch(pair.match("718ak")) # Нет пар.1225>>> displaymatch(pair.match("354aa")) # Пара тузов.1226"<Match: '354aa', groups=('a',)>"1227```12281229Чтобы узнать, из какой карты состоит пара, можно использовать метод [`group()`](https://python-all.ru/3.3/library/re.html#re.match.group) объекта совпадения следующим образом:12301231```python1232>>> pair.match("717ak").group(1)1233'7'12341235# Error because re.match() returns None, which doesn't have a group() method:1236>>> pair.match("718ak").group(1)1237Traceback (most recent call last):1238 File "<pyshell#23>", line 1, in <module>1239 re.match(r".*(.).*\1", "718ak").group(1)1240AttributeError: 'NoneType' object has no attribute 'group'12411242>>> pair.match("354aa").group(1)1243'a'1244```12451246### 6.2.5.2. Имитация scanf()12471248В Python пока нет аналога `scanf()`. Регулярные выражения в целом мощнее, хотя и более многословны, чем строки форматирования `scanf()`. В таблице ниже приведены более или менее эквивалентные соответствия между токенами формата `scanf()` и регулярными выражениями.12491250| `scanf()` Токен | Регулярное выражение |1251| --- | --- |1252| `%c` | `.` |1253| `%5c` | `.{5}` |1254| `%d` | `[-+]?\d+` |1255| `%e`, `%E`, `%f`, `%g` | `[-+]?(\d+(\.\d*)?\|\.\d+)([eE][-+]?\d+)?` |1256| `%i` | `[-+]?(0[xX][\dA-Fa-f]+\|0[0-7]*\|\d+)` |1257| `%o` | `[-+]?[0-7]+` |1258| `%s` | `\S+` |1259| `%u` | `\d+` |1260| `%x`, `%X` | `[-+]?(0[xX])?[\dA-Fa-f]+` |12611262Чтобы извлечь имя файла и числа из строки вида12631264```python1265/usr/sbin/sendmail - 0 errors, 4 warnings1266```12671268Можно использовать формат `scanf()`, например12691270```python1271%s - %d errors, %d warnings1272```12731274Эквивалентное регулярное выражение будет12751276```python1277(\S+) - (\d+) errors, (\d+) warnings1278```12791280### 6.2.5.3. Сравнение search() и match()12811282Python предлагает две разные базовые операции на основе регулярных выражений: [`re.match()`](https://python-all.ru/3.3/library/re.html#re.match) проверяет совпадение только в начале строки, а [`re.search()`](https://python-all.ru/3.3/library/re.html#re.search) проверяет совпадение в любом месте строки (именно так по умолчанию работает Perl).12831284Например:12851286```python1287>>> re.match("c", "abcdef") # Нет совпадения.1288>>> re.search("c", "abcdef") # Совпадает.1289<_sre.SRE_Match object at ...>1290```12911292Регулярные выражения, начинающиеся с `'^'`, можно использовать с [`search()`](https://python-all.ru/3.3/library/re.html#re.search), чтобы ограничить совпадение началом строки:12931294```python1295>>> re.match("c", "abcdef") # Нет совпадения.1296>>> re.search("^c", "abcdef") # Нет совпадения.1297>>> re.search("^a", "abcdef") # Совпадает.1298<_sre.SRE_Match object at ...>1299```13001301Однако обратите внимание, что в режиме [`MULTILINE`](https://python-all.ru/3.3/library/re.html#re.MULTILINE) [`match()`](https://python-all.ru/3.3/library/re.html#re.match) совпадает только в начале строки, тогда как [`search()`](https://python-all.ru/3.3/library/re.html#re.search) с регулярным выражением, начинающимся с `'^'`, будет находить совпадение в начале каждой строки.13021303```python1304>>> re.match('X', 'A\nB\nX', re.MULTILINE) # Нет совпадения.1305>>> re.search('^X', 'A\nB\nX', re.MULTILINE) # Совпадает.1306<_sre.SRE_Match object at ...>1307```13081309### 6.2.5.4. Создание телефонной книги13101311[`split()`](https://python-all.ru/3.3/library/re.html#re.split) разбивает строку на список, используя переданный шаблон в качестве разделителя. Этот метод незаменим для преобразования текстовых данных в структуры данных, которые Python может легко читать и изменять, как показано в следующем примере, создающем телефонный справочник.13121313Сначала – входные данные. Обычно они берутся из файла, здесь мы используем синтаксис тройных кавычек:13141315```python1316>>> text = """Ross McFluff: 834.345.1254 155 Elm Street1317...1318... Ronald Heathmore: 892.345.3428 436 Finley Avenue1319... Frank Burger: 925.541.7625 662 South Dogwood Way1320...1321...1322... Heather Albrecht: 548.326.4584 919 Park Place"""1323```13241325Записи разделяются одним или несколькими символами новой строки. Теперь преобразуем строку в список, где каждая непустая строка будет отдельной записью:13261327```python1328>>> entries = re.split("\n+", text)1329>>> entries1330['Ross McFluff: 834.345.1254 155 Elm Street',1331'Ronald Heathmore: 892.345.3428 436 Finley Avenue',1332'Frank Burger: 925.541.7625 662 South Dogwood Way',1333'Heather Albrecht: 548.326.4584 919 Park Place']1334```13351336Наконец, каждая запись разбивается на список, содержащий имя, фамилию, номер телефона и адрес. Используется параметр `maxsplit` функции [`split()`](https://python-all.ru/3.3/library/re.html#re.split), потому что адрес содержит пробелы – наш разделитель:13371338```python1339>>> [re.split(":? ", entry, 3) for entry in entries]1340[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],1341['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],1342['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],1343['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]1344```13451346Шаблон `:?` соответствует двоеточию после фамилии, поэтому оно не попадает в результирующий список. С помощью `maxsplit`, равного `4`, можно отделить номер дома от названия улицы:13471348```python1349>>> [re.split(":? ", entry, 4) for entry in entries]1350[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],1351['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],1352['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],1353['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]1354```13551356### 6.2.5.5. Обработка текста13571358[`sub()`](https://python-all.ru/3.3/library/re.html#re.sub) заменяет каждое вхождение шаблона на строку или результат функции. В этом примере показано использование [`sub()`](https://python-all.ru/3.3/library/re.html#re.sub) с функцией для «изменения» (munge) текста, то есть перемешивания порядка всех символов в каждом слове предложения, кроме первого и последнего:13591360```python1361>>> def repl(m):1362... inner_word = list(m.group(2))1363... random.shuffle(inner_word)1364... return m.group(1) + "".join(inner_word) + m.group(3)1365>>> text = "Professor Abdolmalek, please report your absences promptly."1366>>> re.sub(r"(\w)(\w+)(\w)", repl, text)1367'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'1368>>> re.sub(r"(\w)(\w+)(\w)", repl, text)1369'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'1370```13711372### 6.2.5.6. Поиск всех наречий13731374[`findall()`](https://python-all.ru/3.3/library/re.html#re.findall) находит *все* вхождения шаблона, а не только первое, как [`search()`](https://python-all.ru/3.3/library/re.html#re.search). Например, если бы писателю потребовалось найти все наречия в тексте, он или она могли бы использовать [`findall()`](https://python-all.ru/3.3/library/re.html#re.findall) следующим образом:13751376```python1377>>> text = "He was carefully disguised but captured quickly by police."1378>>> re.findall(r"\w+ly", text)1379['carefully', 'quickly']1380```13811382### 6.2.5.7. Поиск всех наречий и их позиций13831384Если нужна более полная информация о всех совпадениях шаблона, чем просто текст совпадения, полезна функция [`finditer()`](https://python-all.ru/3.3/library/re.html#re.finditer), поскольку она возвращает [*объекты совпадений*](https://python-all.ru/3.3/library/re.html#match-objects), а не строки. Продолжая предыдущий пример: если бы писателю потребовалось найти все наречия *и их положения* в тексте, он или она мог бы использовать [`finditer()`](https://python-all.ru/3.3/library/re.html#re.finditer) следующим образом:13851386```python1387>>> text = "He was carefully disguised but captured quickly by police."1388>>> for m in re.finditer(r"\w+ly", text):1389... print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))139007-16: carefully139140-47: quickly1392```13931394### 6.2.5.8. Сырые строки13951396Сырые строки (`r"text"`) делают регулярные выражения читаемыми. Без них каждый обратный слеш (`'\'`) в регулярном выражении пришлось бы экранировать дополнительным слешем. Например, следующие две строки кода функционально идентичны:13971398```python1399>>> re.match(r"\W(.)\1\W", " ff ")1400<_sre.SRE_Match object at ...>1401>>> re.match("\\W(.)\\1\\W", " ff ")1402<_sre.SRE_Match object at ...>1403```14041405Если требуется сопоставить литеральный обратный слеш, его необходимо экранировать в регулярном выражении. В сырых строках это означает `r"\\"`. Без сырых строк придётся использовать `"\\\\"`, поэтому следующие строки кода функционально идентичны:14061407```python1408>>> re.match(r"\\", r"\\")1409<_sre.SRE_Match object at ...>1410>>> re.match("\\\\", r"\\")1411<_sre.SRE_Match object at ...>1412```14131414### 6.2.5.9. Написание токенизатора14151416[Токенизатор или сканер](https://python-all.ru/3.3/library/re.html) анализирует строку, чтобы разделить символы на группы. Это полезный первый шаг при написании компилятора или интерпретатора.14171418Категории текста задаются с помощью регулярных выражений. Метод заключается в том, чтобы объединить их в одно главное регулярное выражение и перебирать последовательные совпадения:14191420```python1421import collections1422import re14231424Token = collections.namedtuple('Token', ['typ', 'value', 'line', 'column'])14251426def tokenize(s):1427 keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}1428 token_specification = [1429 ('NUMBER', r'\d+(\.\d*)?'), # Целое или десятичное число.1430 ('ASSIGN', r':='), # Оператор присваивания.1431 ('END', r';'), # Терминатор инструкции.1432 ('ID', r'[A-Za-z]+'), # Идентификаторы.1433 ('OP', r'[+*\/\-]'), # Арифметические операторы.1434 ('NEWLINE', r'\n'), # Концы строк.1435 ('SKIP', r'[ \t]'), # Пропускать пробелы и табуляции.1436 ]1437 tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)1438 get_token = re.compile(tok_regex).match1439 line = 11440 pos = line_start = 01441 mo = get_token(s)1442 while mo is not None:1443 typ = mo.lastgroup1444 if typ == 'NEWLINE':1445 line_start = pos1446 line += 11447 elif typ != 'SKIP':1448 val = mo.group(typ)1449 if typ == 'ID' and val in keywords:1450 typ = val1451 yield Token(typ, val, line, mo.start()-line_start)1452 pos = mo.end()1453 mo = get_token(s, pos)1454 if pos != len(s):1455 raise RuntimeError('Unexpected character %r on line %d' %(s[pos], line))14561457statements = '''1458 IF quantity THEN1459 total := total + price * quantity;1460 tax := price * 0.05;1461 ENDIF;1462'''14631464for token in tokenize(statements):1465 print(token)1466```14671468Токенизатор выдаёт следующий результат:14691470```python1471Token(typ='IF', value='IF', line=2, column=5)1472Token(typ='ID', value='quantity', line=2, column=8)1473Token(typ='THEN', value='THEN', line=2, column=17)1474Token(typ='ID', value='total', line=3, column=9)1475Token(typ='ASSIGN', value=':=', line=3, column=15)1476Token(typ='ID', value='total', line=3, column=18)1477Token(typ='OP', value='+', line=3, column=24)1478Token(typ='ID', value='price', line=3, column=26)1479Token(typ='OP', value='*', line=3, column=32)1480Token(typ='ID', value='quantity', line=3, column=34)1481Token(typ='END', value=';', line=3, column=42)1482Token(typ='ID', value='tax', line=4, column=9)1483Token(typ='ASSIGN', value=':=', line=4, column=13)1484Token(typ='ID', value='price', line=4, column=16)1485Token(typ='OP', value='*', line=4, column=22)1486Token(typ='NUMBER', value='0.05', line=4, column=24)1487Token(typ='END', value=';', line=4, column=28)1488Token(typ='ENDIF', value='ENDIF', line=5, column=5)1489Token(typ='END', value=';', line=5, column=10)1490```1491