regex.md

1> **Источник:** https://python-all.ru/3.5/howto/regex.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# Регулярные выражения: руководство89| Автор: | A.M. Kuchling \<[amk@amk.ca](https://python-all.ru/3.5/howto/regex.html)\> |10| --- | --- |1112Аннотация1314Этот документ – вводное руководство по использованию регулярных выражений в Python с модулем [`re`](https://python-all.ru/3.5/library/re.html#module-re). Оно даёт более плавное введение, чем соответствующий раздел в справочнике по библиотеке.1516## Введение1718Регулярные выражения (называемые RE, или regex, или regex-шаблоны) – это, по сути, крошечный, узкоспециализированный язык программирования, встроенный в Python и доступный через модуль [`re`](https://python-all.ru/3.5/library/re.html#module-re). С помощью этого небольшого языка вы задаёте правила для множества возможных строк, которые хотите сопоставить; это множество может содержать английские предложения, адреса электронной почты, команды TeX или что угодно. Затем можно задавать вопросы вроде «Соответствует ли эта строка шаблону?» или «Есть ли совпадение с шаблоном где-либо в этой строке?». С помощью RE можно также изменять строку или разделять её различными способами.1920Шаблоны регулярных выражений компилируются в набор байткодов, которые затем выполняются механизмом сопоставления, написанным на C. Для продвинутого использования может потребоваться тщательно следить за тем, как механизм будет выполнять данное RE, и писать RE определённым образом, чтобы получить байткод, работающий быстрее. Оптимизация не рассматривается в этом документе, поскольку она требует хорошего понимания внутреннего устройства механизма сопоставления.2122Язык регулярных выражений относительно мал и ограничен, поэтому не все задачи обработки строк можно решить с помощью регулярных выражений. Существуют также задачи, которые *можно* выполнить с помощью регулярных выражений, но выражения оказываются очень сложными. В таких случаях, возможно, лучше написать код на Python для обработки; хотя код на Python будет медленнее, чем сложное регулярное выражение, он, вероятно, будет более понятным.2324## Простые шаблоны2526Начнём с изучения самых простых регулярных выражений. Поскольку регулярные выражения используются для работы со строками, начнём с самой распространённой задачи: сопоставления символов.2728Подробное объяснение теоретических основ регулярных выражений (детерминированные и недетерминированные конечные автоматы) можно найти почти в любом учебнике по написанию компиляторов.2930### Сопоставление символов3132Большинство букв и символов сопоставляются сами с собой. Например, регулярное выражение `test` будет точно соответствовать строке `test`. (Можно включить регистронезависимый режим, который позволит этому РВ сопоставляться также с `Test` или `TEST`; подробнее об этом позже.)3334Из этого правила есть исключения: некоторые символы являются специальными *метасимволами* и не сопоставляются сами с собой. Вместо этого они указывают, что должно быть сопоставлено что-то необычное, или влияют на другие части РВ, повторяя их или меняя их значение. Значительная часть этого документа посвящена обсуждению различных метасимволов и их действий.3536Вот полный список метасимволов; их значения будут рассмотрены в остальной части этого HOWTO.3738```text39. ^ $ * + ? { } [ ] \ | ( )40```4142Первые метасимволы, которые мы рассмотрим, – это `[` и `]`. Они используются для определения символьного класса – набора символов, которые нужно сопоставить. Символы можно перечислить по отдельности, или указать диапазон символов, задав два символа и разделив их дефисом `'-'`. Например, `[abc]` будет соответствовать любому из символов `a`, `b` или `c`; это то же самое, что `[a-c]`, где диапазон выражает тот же набор символов. Если нужно сопоставлять только строчные буквы, РВ будет `[a-z]`.4344Метасимволы не активны внутри классов. Например, `[akm$]` будет соответствовать любому из символов `'a'`, `'k'`, `'m'` или `'$'`; `'$'` обычно является метасимволом, но внутри символьного класса он лишается своего особого значения.4546Вы можете сопоставить символы, не перечисленные в классе, *дополнив* набор. Это обозначается включением `'^'` в качестве первого символа класса; `'^'` вне символьного класса просто соответствует `'^'` символу. Например, `[^5]` будет соответствовать любому символу, кроме `'5'`.4748Пожалуй, самый важный метасимвол – обратная косая черта, `\`. Как и в строковых литералах Python, за обратной косой чертой могут следовать различные символы для обозначения специальных последовательностей. Она также используется для экранирования всех метасимволов, чтобы их можно было сопоставлять в шаблонах; например, если нужно сопоставить `[` или `\`, можно поставить перед ними обратную косую черту, чтобы убрать их специальное значение: `\[` или `\\`.4950Некоторые специальные последовательности, начинающиеся с `'\'`, представляют предопределённые наборы символов, которые часто бывают полезны: например, набор цифр, набор букв или набор всего, что не является пробельным символом.5152Рассмотрим пример: `\w` соответствует любому буквенно-цифровому символу. Если шаблон регулярного выражения задан в байтах, это эквивалентно классу `[a-zA-Z0-9_]`. Если шаблон – строка, `\w` будет соответствовать всем символам, помеченным как буквы в базе данных Unicode, которую предоставляет модуль [`unicodedata`](https://python-all.ru/3.5/library/unicodedata.html#module-unicodedata). Можно использовать более ограниченное определение `\w` в строковом шаблоне, указав флаг [`re.ASCII`](https://python-all.ru/3.5/library/re.html#re.ASCII) при компиляции регулярного выражения.5354Следующий список специальных последовательностей неполон. Полный список последовательностей и расширенных определений классов для строковых шаблонов Unicode см. в последней части [Синтаксис регулярных выражений](https://python-all.ru/3.5/library/re.html#re-syntax) в справочнике стандартной библиотеки. В общем, версии Unicode соответствуют любому символу, находящемуся в соответствующей категории в базе данных Unicode.5556**`\d`**5758Соответствует любой десятичной цифре; эквивалентно классу5960`[0-9]`6162.6364**`\D`**6566Соответствует любому нецифровому символу; эквивалентно классу6768`[^0-9]`6970.7172**`\s`**7374Соответствует любому пробельному символу; эквивалентно классу7576`[ \t\n\r\f\v]`7778.7980**`\S`**8182Соответствует любому непробельному символу; эквивалентно классу8384`[^ \t\n\r\f\v]`8586.8788**`\w`**8990Соответствует любому буквенно-цифровому символу; эквивалентно классу9192`[a-zA-Z0-9_]`9394.9596**`\W`**9798Соответствует любому не буквенно-цифровому символу; эквивалентно классу99100`[^a-zA-Z0-9_]`101102.103104Эти последовательности можно включать внутрь символьного класса. Например, `[\s,.]` – это символьный класс, который будет соответствовать любому пробельному символу, или `','`, или `'.'`.105106Последний метасимвол в этом разделе – `.`. Он соответствует любому символу, кроме символа новой строки, и есть альтернативный режим (`re.DOTALL`), в котором он будет соответствовать даже новой строке. `'.'` часто используется, когда нужно сопоставить «любой символ».107108### Повторяющиеся элементы109110Возможность сопоставлять различные наборы символов – это первое, что регулярные выражения умеют делать, чего уже нельзя сделать с помощью методов строк. Однако если бы это была единственная дополнительная возможность регулярных выражений, они не были бы большим достижением. Ещё одна возможность – указывать, что части РВ должны повторяться определённое количество раз.111112Первый метасимвол для повторения, который мы рассмотрим, – это `*`. `*` не соответствует литеральному символу `*`; вместо этого он указывает, что предыдущий символ может быть сопоставлен ноль или более раз, а не ровно один раз.113114Например, `ca*t` будет соответствовать `ct` (0 `a` символов), `cat` (1 `a`), `caaat` (3 `a` символа) и так далее. У движка регулярных выражений есть различные внутренние ограничения, связанные с размером типа `int` в C, которые не позволяют ему обрабатывать более 2 миллиардов `a` символов; шаблоны обычно не пишутся для обработки такого объёма данных.115116Повторения, такие как `*`, являются *жадными*; при повторении РВ движок сопоставления будет стараться повторить его как можно больше раз. Если более поздние части шаблона не совпадают, движок сопоставления отступает и пробует снова с меньшим числом повторений.117118Пошаговый пример прояснит это. Рассмотрим выражение `a[bcd]*b`. Оно соответствует букве `'a'`, нулю или более букв из класса `[bcd]` и заканчивается символом `'b'`. Теперь представим, что это РВ сопоставляется со строкой `abcbd`.119120| Шаг | Совпадение | Пояснение |121| --- | --- | --- |122| 1 | `a` | `a` в РВ совпадает. |123| 2 | `abcbd` | Движок сопоставляет `[bcd]*`, продвигаясь так далеко, как может, то есть до конца строки. |124| 3 | *Неудача* | Движок пытается сопоставить `b`, но текущая позиция находится в конце строки, поэтому попытка не удаётся. |125| 4 | `abcb` | Отступ, чтобы `[bcd]*` сопоставляло на один символ меньше. |126| 5 | *Неудача* | Снова попробовать `b`, но текущая позиция находится на последнем символе, которым является `'d'`. |127| 6 | `abc` | Снова отступ, чтобы `[bcd]*` сопоставляло только `bc`. |128| 6 | `abcb` | Снова попробовать `b`. На этот раз символ в текущей позиции – `'b'`, поэтому совпадение находится. |129130Конец регулярного выражения достигнут, и оно сопоставило `abcb`. Это показывает, как движок сопоставления сначала заходит так далеко, как может, а если совпадение не найдено, постепенно отступает и снова и снова перебирает остальную часть регулярного выражения. Он будет отступать до тех пор, пока не попробует ноль совпадений для `[bcd]*`, и если это впоследствии не удастся, движок приходит к выводу, что строка вообще не соответствует регулярному выражению.131132Ещё один повторяющийся метасимвол – `+`, который соответствует одному или более вхождений. Обратите внимание на разницу между `*` и `+`; `*` соответствует *нулю* или более раз, так что повторяющийся элемент может вообще отсутствовать, тогда как `+` требует как минимум *одного* повторения. Для похожего примера, `ca+t` будет соответствовать `cat` (1 `a`), `caaat` (3 `a`), но не будет соответствовать `ct`.133134Есть ещё два повторяющихся квантификатора. Символ вопросительного знака `?`, соответствует одному или нулю повторений; его можно считать пометкой чего-либо как необязательного. Например, `home-?brew` соответствует либо `homebrew`, либо `home-brew`.135136Самый сложный повторяющийся квантификатор – `{m,n}`, где *m* и *n* – десятичные целые числа. Этот квантификатор означает, что должно быть как минимум *m* повторений и как максимум *n*. Например, `a/{1,3}b` соответствует `a/b`, `a//b` и `a///b`. Он не соответствует `ab` (без слэшей) или `a////b` (с четырьмя).137138Можно опустить либо *m*, либо *n*; в этом случае подразумевается разумное значение для отсутствующего параметра. Пропуск *m* интерпретируется как нижняя граница 0, а пропуск *n* приводит к верхней границе бесконечности – на самом деле верхняя граница – это упомянутый ранее предел в 2 миллиарда, но её можно считать бесконечностью.139140Можно заметить, что три остальных квантификатора можно выразить через эту нотацию. `{0,}` – то же, что `*`, `{1,}` эквивалентен `+`, а `{0,1}` – то же, что `?`. Лучше использовать `*`, `+` или `?`, когда это возможно, просто потому что они короче и легче читаются.141142## Использование регулярных выражений143144Теперь, когда мы рассмотрели некоторые простые регулярные выражения, как же их использовать в Python? Модуль [`re`](https://python-all.ru/3.5/library/re.html#module-re) предоставляет интерфейс к движку регулярных выражений, позволяя компилировать регулярные выражения в объекты и затем выполнять с ними сопоставление.145146### Компиляция регулярных выражений147148Регулярные выражения компилируются в объекты шаблонов, которые имеют методы для различных операций, таких как поиск совпадений с шаблоном или выполнение подстановок в строке.149150```python151>>> import re152>>> p = re.compile('ab*')153>>> p154re.compile('ab*')155```156157[`re.compile()`](https://python-all.ru/3.5/library/re.html#re.compile) также принимает необязательный аргумент *flags*, используемый для включения различных специальных возможностей и вариантов синтаксиса. Мы рассмотрим доступные настройки позже, а пока достаточно одного примера:158159```python160>>> p = re.compile('ab*', re.IGNORECASE)161```162163RE передаётся в [`re.compile()`](https://python-all.ru/3.5/library/re.html#re.compile) в виде строки. RE обрабатываются как строки, поскольку регулярные выражения не являются частью ядра языка Python, и для их записи не был создан специальный синтаксис. (Существуют приложения, которым RE вообще не нужны, поэтому нет необходимости раздувать спецификацию языка, включая их.) Вместо этого модуль [`re`](https://python-all.ru/3.5/library/re.html#module-re) – это просто модуль-расширение на C, поставляемый с Python, точно так же, как модули [`socket`](https://python-all.ru/3.5/library/socket.html#module-socket) или [`zlib`](https://python-all.ru/3.5/library/zlib.html#module-zlib).164165Размещение RE в строках сохраняет язык Python более простым, но имеет один недостаток, который является темой следующего раздела.166167### Проблема обратной косой черты168169Как было сказано ранее, регулярные выражения используют символ обратной косой черты (`'\'`) для обозначения специальных форм или для использования специальных символов без их специального значения. Это конфликтует с использованием того же символа в строковых литералах Python для той же цели.170171Допустим, нужно написать RE, которое бы совпадало со строкой `\section`, которая может встретиться в файле LaTeX. Чтобы понять, что написать в коде программы, начнём с желаемой строки для совпадения. Затем необходимо экранировать все обратные слеши и другие метасимволы, поставив перед ними обратную косую черту, в результате получится строка `\\section`. Итоговая строка, которую нужно передать в [`re.compile()`](https://python-all.ru/3.5/library/re.html#re.compile), должна быть `\\section`. Однако, чтобы представить это в виде строкового литерала Python, оба обратных слеша нужно экранировать *снова*.172173| Символы | Этап |174| --- | --- |175| `\section` | Строка для совпадения |176| `\\section` | Экранированный обратный слеш для [`re.compile()`](https://python-all.ru/3.5/library/re.html#re.compile) |177| `"\\\\section"` | Экранированные обратные слеши для строкового литерала |178179Короче говоря, для сопоставления с литералом обратной косой черты нужно записать `'\\\\'` в качестве строки RE, потому что регулярное выражение должно быть `\\`, а каждый обратный слеш должен быть представлен как `\\` внутри обычного строкового литерала Python. В RE, где обратные слеши встречаются многократно, это приводит к множеству повторных слешей и делает итоговые строки трудными для понимания.180181Решение – использовать сырые строки Python для регулярных выражений; обратные слеши не обрабатываются особым образом в строковом литерале с префиксом `'r'`, поэтому `r"\n"` – это двухсимвольная строка, содержащая `'\'` и `'n'`, а `"\n"` – односимвольная строка, содержащая перевод строки. Регулярные выражения часто записываются в коде Python с использованием этой сырой строковой записи.182183| Обычная строка | Сырая строка |184| --- | --- |185| `"ab*"` | `r"ab*"` |186| `"\\\\section"` | `r"\\section"` |187| `"\\w+\\s+\\1"` | `r"\w+\s+\1"` |188189### Выполнение поиска совпадений190191Как только у вас есть объект, представляющий скомпилированное регулярное выражение, что с ним делать? Объекты Pattern имеют несколько методов и атрибутов. Здесь будут рассмотрены только самые важные; за полным списком обращайтесь к документации [`re`](https://python-all.ru/3.5/library/re.html#module-re).192193| Метод/Атрибут | Назначение |194| --- | --- |195| `match()` | Определяет, совпадает ли RE в начале строки. |196| `search()` | Сканирует строку в поисках любого места, где данное регулярное выражение совпадает. |197| `findall()` | Находит все подстроки, совпадающие с регулярным выражением, и возвращает их в виде списка. |198| `finditer()` | Find all substrings where the RE matches, and returns them as an [iterator](https://python-all.ru/3.5/glossary.html#term-iterator). |199200[`match()`](https://python-all.ru/3.5/library/re.html#re.regex.match) и [`search()`](https://python-all.ru/3.5/library/re.html#re.regex.search) возвращают `None`, если совпадение не найдено. В случае успеха возвращается экземпляр [объекта совпадения](https://python-all.ru/3.5/library/re.html#match-objects), содержащий информацию о совпадении: где оно начинается и заканчивается, совпавшую подстроку и другое.201202Это можно изучить, экспериментируя интерактивно с модулем [`re`](https://python-all.ru/3.5/library/re.html#module-re) Если у вас есть [`tkinter`](https://python-all.ru/3.5/library/tkinter.html#module-tkinter), вы также можете посмотреть [Tools/demo/redemo.py](https://python-all.ru/src/3.5/Tools/demo/redemo.py) – демонстрационную программу, входящую в состав дистрибутива Python. Она позволяет вводить регулярные выражения и строки и показывает, совпадает ли выражение или нет. `redemo.py` может быть весьма полезен при отладке сложных регулярных выражений.203204В данном HOWTO используется стандартный интерпретатор Python для примеров. Сначала запустите интерпретатор Python, импортируйте модуль [`re`](https://python-all.ru/3.5/library/re.html#module-re) и скомпилируйте регулярное выражение:205206```python207>>> import re208>>> p = re.compile('[a-z]+')209>>> p210re.compile('[a-z]+')211```212213Теперь можно попробовать сопоставить различные строки с РВ `[a-z]+`. Пустая строка не должна совпадать, поскольку `+` означает «одно или более повторений». `match()` в этом случае должен вернуть `None`, что заставит интерпретатор ничего не выводить. Можно явно напечатать результат `match()`, чтобы прояснить это.214215```python216>>> p.match("")217>>> print(p.match(""))218None219```220221Теперь попробуем на строке, которая должна совпадать, например `tempo`. В этом случае `match()` вернёт [объект совпадения](https://python-all.ru/3.5/library/re.html#match-objects), так что сохраните результат в переменную для последующего использования.222223```python224>>> m = p.match('tempo')225>>> m  226<_sre.SRE_Match object; span=(0, 5), match='tempo'>227```228229Теперь можно запросить у [объекта match](https://python-all.ru/3.5/library/re.html#match-objects) информацию о соответствующей строке. [Объекты match](https://python-all.ru/3.5/library/re.html#match-objects) также имеют несколько методов и атрибутов; наиболее важные из них:230231| Метод/Атрибут | Назначение |232| --- | --- |233| `group()` | Возвращает строку, совпавшую с РВ |234| `start()` | Возвращает начальную позицию совпадения |235| `end()` | Возвращает конечную позицию совпадения |236| `span()` | Возвращает кортеж с (начало, конец) позициями совпадения |237238Применение этих методов быстро прояснит их смысл:239240```python241>>> m.group()242'tempo'243>>> m.start(), m.end()244(0, 5)245>>> m.span()246(0, 5)247```248249[`group()`](https://python-all.ru/3.5/library/re.html#re.match.group) возвращает подстроку, совпавшую с RE. [`start()`](https://python-all.ru/3.5/library/re.html#re.match.start) и [`end()`](https://python-all.ru/3.5/library/re.html#re.match.end) возвращают начальный и конечный индекс совпадения. [`span()`](https://python-all.ru/3.5/library/re.html#re.match.span) возвращает оба индекса в одном кортеже. Поскольку метод `match()` проверяет совпадение только в начале строки, `start()` всегда будет равен нулю. Однако метод `search()` шаблонов просматривает строку, поэтому в таком случае совпадение может начинаться не с нуля.250251```python252>>> print(p.match('::: message'))253None254>>> m = p.search('::: message'); print(m)  255<_sre.SRE_Match object; span=(4, 11), match='message'>256>>> m.group()257'message'258>>> m.span()259(4, 11)260```261262В реальных программах наиболее распространённый подход – сохранить [объект совпадения](https://python-all.ru/3.5/library/re.html#match-objects) в переменную, а затем проверить, был ли он `None`. Обычно это выглядит так:263264```python265p = re.compile( ... )266m = p.match( 'string goes here' )267if m:268    print('Match found: ', m.group())269else:270    print('No match')271```272273Два метода шаблонов возвращают все совпадения для шаблона. [`findall()`](https://python-all.ru/3.5/library/re.html#re.regex.findall) возвращает список совпавших строк:274275```python276>>> p = re.compile('\d+')277>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')278['12', '11', '10']279```280281`findall()` должен создать весь список, прежде чем его можно будет вернуть как результат. Метод [`finditer()`](https://python-all.ru/3.5/library/re.html#re.regex.finditer) возвращает последовательность экземпляров [объектов совпадения](https://python-all.ru/3.5/library/re.html#match-objects) в виде [итератора](https://python-all.ru/3.5/glossary.html#term-iterator):282283```python284>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')285>>> iterator  286<callable_iterator object at 0x...>287>>> for match in iterator:288...     print(match.span())289...290(0, 2)291(22, 24)292(29, 31)293```294295### Функции уровня модуля296297Необязательно создавать объект шаблона и вызывать его методы; модуль [`re`](https://python-all.ru/3.5/library/re.html#module-re) также предоставляет функции верхнего уровня, называемые [`match()`](https://python-all.ru/3.5/library/re.html#re.match), [`search()`](https://python-all.ru/3.5/library/re.html#re.search), [`findall()`](https://python-all.ru/3.5/library/re.html#re.findall), [`sub()`](https://python-all.ru/3.5/library/re.html#re.sub) и так далее. Эти функции принимают те же аргументы, что и соответствующий метод шаблона, с добавлением строки РВ в качестве первого аргумента, и по-прежнему возвращают либо `None`, либо экземпляр [объекта совпадения](https://python-all.ru/3.5/library/re.html#match-objects).298299```python300>>> print(re.match(r'From\s+', 'Fromage amk'))301None302>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')  303<_sre.SRE_Match object; span=(0, 5), match='From '>304```305306Под капотом эти функции просто создают объект шаблона и вызывают на нём соответствующий метод. Они также сохраняют скомпилированный объект в кеш, так что последующие вызовы с тем же РВ не будут каждый раз разбирать шаблон заново.307308Следует ли использовать функции уровня модуля или получать шаблон и вызывать его методы самостоятельно? При доступе к регулярному выражению внутри цикла предварительная компиляция позволит сэкономить несколько вызовов функций. Вне циклов, благодаря внутреннему кешу, разница невелика.309310### Флаги компиляции311312Флаги компиляции позволяют изменять некоторые аспекты работы регулярных выражений. Флаги доступны в модуле [`re`](https://python-all.ru/3.5/library/re.html#module-re) под двумя именами: длинным, например `IGNORECASE`, и коротким, однобуквенным, например `I`. (Для знакомых с модификаторами шаблонов Perl: однобуквенные формы используют те же буквы; например, короткая форма [`re.VERBOSE`](https://python-all.ru/3.5/library/re.html#re.VERBOSE) – это [`re.X`](https://python-all.ru/3.5/library/re.html#re.X).) Несколько флагов можно указать с помощью побитового ИЛИ; например, `re.I | re.M` устанавливает оба флага `I` и `M`.313314Ниже приведена таблица доступных флагов, а затем более подробное описание каждого из них.315316| Флаг | Значение |317| --- | --- |318| `ASCII`, `A` | Заставляет несколько управляющих последовательностей, таких как `\w`, `\b`, `\s` и `\d`, совпадать только с ASCII-символами с соответствующим свойством. |319| `DOTALL`, `S` | Заставляет `.` соответствовать любому символу, включая символы новой строки |320| `IGNORECASE`, `I` | Выполняет регистронезависимые сопоставления |321| `LOCALE`, `L` | Выполняет сопоставление с учётом локали |322| `MULTILINE`, `M` | Многострочное сопоставление, затрагивающее `^` и `$` |323| `VERBOSE`, `X` (для ‘extended’). | Включает подробные (verbose) регулярные выражения, которые можно организовать более чисто и понятно. |324325#### `I`326327#### `IGNORECASE`328329Выполняет регистронезависимое сопоставление; классы символов и литеральные строки будут соответствовать буквам, игнорируя регистр. Например, `[A-Z]` будет соответствовать также строчным буквам, а `Spam` будет соответствовать `Spam`, `spam` или `spAM`. Это приведение к нижнему регистру не учитывает текущую локаль; оно будет учитывать её, если также установить флаг `LOCALE`.330331#### `L`332333#### `LOCALE`334335Делает `\w`, `\W`, `\b` и `\B` зависимыми от текущей локали вместо базы данных Юникода.336337Локали – это возможность библиотеки C, предназначенная для помощи в написании программ, которые учитывают различия языков. Например, при обработке французского текста хотелось бы иметь возможность написать `\w+` для поиска слов, но `\w` соответствует только классу символов `[A-Za-z]`; он не будет соответствовать `'é'` или `'ç'`. Если система настроена правильно и выбрана французская локаль, некоторые C-функции сообщат программе, что `'é'` также следует считать буквой. Установка флага `LOCALE` при компиляции регулярного выражения приведёт к тому, что результирующий скомпилированный объект будет использовать эти C-функции для `\w`; это медленнее, но также позволяет `\w+` находить французские слова, как и ожидается.338339#### `M`340341#### `MULTILINE`342343(`^` и `$` пока не объяснены; они будут представлены в разделе [Дополнительные метасимволы](https://python-all.ru/3.5/howto/regex.html#more-metacharacters).)344345Обычно `^` сопоставляется только в начале строки, а `$` – только в конце строки и непосредственно перед символом новой строки (если он есть) в конце строки. Когда указан этот флаг, `^` сопоставляется в начале строки и в начале каждой строки внутри строки, сразу после каждого символа новой строки. Аналогично, метасимвол `$` сопоставляется в конце строки и в конце каждой строки (непосредственно перед каждым символом новой строки).346347#### `S`348349#### `DOTALL`350351Заставляет специальный символ `'.'` сопоставляться с любым символом, включая символ новой строки; без этого флага `'.'` будет сопоставляться с любым символом, *кроме* символа новой строки.352353#### `A`354355#### `ASCII`356357Заставляет `\w`, `\W`, `\b`, `\B`, `\s` и `\S` выполнять сопоставление только с ASCII вместо полного сопоставления с Unicode. Это имеет смысл только для строковых шаблонов и игнорируется для байтовых шаблонов.358359#### `X`360361#### `VERBOSE`362363Этот флаг позволяет писать более читаемые регулярные выражения, предоставляя больше гибкости в их форматировании. Когда этот флаг указан, пробельные символы внутри строки регулярного выражения игнорируются, за исключением случаев, когда пробел находится внутри символьного класса или перед ним стоит неэкранированная обратная косая черта; это позволяет более четко организовывать и расставлять отступы в регулярном выражении. Этот флаг также позволяет помещать комментарии внутри регулярного выражения, которые будут игнорироваться движком; комментарии обозначаются символом `'#'`, который не находится внутри символьного класса и не предваряется неэкранированной обратной косой чертой.364365Например, вот RE, использующий [`re.VERBOSE`](https://python-all.ru/3.5/library/re.html#re.VERBOSE); посмотрите, насколько его легче читать.366367```python368charref = re.compile(r"""369 &[#]                # Start of a numeric entity reference370 (371     0[0-7]+         # Octal form372   | [0-9]+          # Decimal form373   | x[0-9a-fA-F]+   # Hexadecimal form374 )375 ;                   # Trailing semicolon376""", re.VERBOSE)377```378379Без режима verbose регулярное выражение выглядело бы так:380381```python382charref = re.compile("&#(0[0-7]+"383                     "|[0-9]+"384                     "|x[0-9a-fA-F]+);")385```386387В примере выше автоматическая конкатенация строковых литералов Python использовалась, чтобы разбить RE на более мелкие части, но он всё равно сложнее для понимания, чем версия с [`re.VERBOSE`](https://python-all.ru/3.5/library/re.html#re.VERBOSE).388389## Дополнительные возможности шаблонов390391До сих пор мы рассмотрели только часть возможностей регулярных выражений. В этом разделе мы рассмотрим некоторые новые метасимволы и способы использования групп для извлечения частей сопоставленного текста.392393### Дополнительные метасимволы394395Остались некоторые метасимволы, которые мы ещё не рассмотрели. Большинство из них будет рассмотрено в этом разделе.396397Некоторые из оставшихся метасимволов – это *утверждения нулевой длины*. Они не заставляют движок продвигаться по строке; вместо этого они вообще не потребляют символов и просто возвращают успех или неудачу. Например, `\b` – это утверждение, что текущая позиция находится на границе слова; позиция при этом не меняется `\b` вообще. Это означает, что утверждения нулевой длины не следует повторять, потому что если они совпадают один раз в данной позиции, то они, очевидно, могут совпадать бесконечное число раз.398399**`|`**400401Альтернация, или оператор «или». Если A и B – регулярные выражения, `A|B` будет соответствовать любой строке, которая соответствует либо `A`, либо `B`. `|` имеет очень низкий приоритет, чтобы он работал разумно при альтернации многосимвольных строк. `Crow|Servo` будет соответствовать либо `Crow`, либо `Servo`, а не `Cro`, `'w'` или `'S'`, и `ervo`.402403Чтобы сопоставить литерал `'|'`, используйте `\|` или заключите его в символьный класс, как в `[|]`.404405**`^`**406407Совпадение в начале строк. Если не установлен флаг `MULTILINE`, соответствует только в начале строки. В режиме `MULTILINE` также совпадает сразу после каждого перевода строки внутри строки.408409Например, если требуется найти слово `From` только в начале строки, нужно использовать RE `^From`.410411```python412>>> print(re.search('^From', 'From Here to Eternity'))  413<_sre.SRE_Match object; span=(0, 4), match='From'>414>>> print(re.search('^From', 'Reciting From Memory'))415None416```417418**`$`**419420Совпадение в конце строки, которая определяется как конец строки или любая позиция, за которой следует символ перевода строки.421422```python423>>> print(re.search('}$', '{block}'))  424<_sre.SRE_Match object; span=(6, 7), match='}'>425>>> print(re.search('}$', '{block} '))426None427>>> print(re.search('}$', '{block}\n'))  428<_sre.SRE_Match object; span=(6, 7), match='}'>429```430431Чтобы сопоставить литерал `'$'`, используйте `\$` или заключите его в символьный класс, как в `[$]`.432433**`\A`**434435Совпадение только в начале строки. Вне режима436437`MULTILINE`438439`\A`440441и442443`^`444445фактически одинаковы. В режиме446447`MULTILINE`448449они различаются:450451`\A`452453по-прежнему совпадает только в начале строки, а454455`^`456457может совпадать в любом месте строки после символа перевода строки.458459**`\Z`**460461Совпадение только в конце строки.462463**`\b`**464465Граница слова. Это утверждение нулевой длины, которое совпадает только в начале или конце слова. Слово определяется как последовательность буквенно-цифровых символов, поэтому конец слова обозначается пробелом или не-буквенно-цифровым символом.466467Следующий пример находит `class` только когда это целое слово; он не совпадёт, если оно содержится внутри другого слова.468469```python470>>> p = re.compile(r'\bclass\b')471>>> print(p.search('no class at all'))  472<_sre.SRE_Match object; span=(3, 8), match='class'>473>>> print(p.search('the declassified algorithm'))474None475>>> print(p.search('one subclass is'))476None477```478479Есть две тонкости, которые следует помнить при использовании этой специальной последовательности. Во-первых, это худшее столкновение между строковыми литералами Python и последовательностями регулярных выражений. В строковых литералах Python `\b` – это символ backspace, ASCII-код 8. Если не используются сырые строки, Python преобразует `\b` в backspace, и RE не будет совпадать так, как ожидается. Следующий пример выглядит так же, как предыдущий RE, но в нём опущен `'r'` перед строкой RE.480481```python482>>> p = re.compile('\bclass\b')483>>> print(p.search('no class at all'))484None485>>> print(p.search('\b' + 'class' + '\b'))  486<_sre.SRE_Match object; span=(0, 7), match='\x08class\x08'>487```488489Во-вторых, внутри символьного класса, где это утверждение не используется, `\b` представляет символ backspace для совместимости со строковыми литералами Python.490491**`\B`**492493Ещё одно утверждение нулевой длины, противоположное494495`\b`496497, совпадает только когда текущая позиция не находится на границе слова.498499### Группировка500501Часто требуется получить больше информации, чем просто – совпало RE или нет. Регулярные выражения часто используются для разбора строк с помощью RE, разделённого на несколько подгрупп, каждая из которых соответствует интересующему компоненту. Например, строка заголовка RFC-822 разделена на имя заголовка и значение, разделённые `':'`, так:502503```python504From: author@example.com505User-Agent: Thunderbird 1.5.0.9 (X11/20061227)506MIME-Version: 1.0507To: editor@example.com508```509510Это можно обработать, написав регулярное выражение, которое сопоставляет всю строку заголовка, и имеет одну группу для имени заголовка и другую – для значения заголовка.511512Группы обозначаются метасимволами `'('`, `')'`. `'('` и `')'` имеют примерно тот же смысл, что и в математических выражениях: они группируют содержащиеся в них выражения, и содержимое группы можно повторять с помощью повторяющегося квантификатора, например `*`, `+`, `?` или `{m,n}`. Например, `(ab)*` будет соответствовать нулю или более повторениям `ab`.513514```python515>>> p = re.compile('(ab)*')516>>> print(p.match('ababababab').span())517(0, 10)518```519520Группы, обозначенные `'('`, `')'`, также захватывают начальный и конечный индекс соответствующего текста; их можно получить, передав аргумент методам `group()`, `start()`, `end()` и `span()`. Группы нумеруются, начиная с 0. Группа 0 присутствует всегда; это всё регулярное выражение, поэтому [методы объекта match](https://python-all.ru/3.5/library/re.html#match-objects) имеют группу 0 в качестве аргумента по умолчанию. Позже мы увидим, как задавать группы, которые не захватывают диапазон соответствующего текста.521522```python523>>> p = re.compile('(a)b')524>>> m = p.match('ab')525>>> m.group()526'ab'527>>> m.group(0)528'ab'529```530531Подгруппы нумеруются слева направо, начиная с 1. Группы могут быть вложенными; чтобы определить номер, нужно просто посчитать открывающие скобки, идя слева направо.532533```python534>>> p = re.compile('(a(b)c)d')535>>> m = p.match('abcd')536>>> m.group(0)537'abcd'538>>> m.group(1)539'abc'540>>> m.group(2)541'b'542```543544`group()` можно передать несколько номеров групп одновременно, и в этом случае она вернёт кортеж, содержащий соответствующие значения для этих групп.545546```python547>>> m.group(2,1,2)548('b', 'abc', 'b')549```550551Метод `groups()` возвращает кортеж, содержащий строки всех подгрупп, от 1 до их количества.552553```python554>>> m.groups()555('abc', 'b')556```557558Обратные ссылки в шаблоне позволяют указать, что содержимое ранее захваченной группы должно также присутствовать в текущей позиции строки. Например, `\1` будет успешным, если точное содержимое группы 1 можно найти в текущей позиции, иначе – нет. Помните, что строковые литералы Python также используют обратную косую черту с числами для включения произвольных символов в строку, поэтому обязательно используйте сырую строку при включении обратных ссылок в RE.559560Например, следующее RE обнаруживает удвоенные слова в строке.561562```python563>>> p = re.compile(r'(\b\w+)\s+\1')564>>> p.search('Paris in the the spring').group()565'the the'566```567568Обратные ссылки такого рода редко бывают полезны при простом поиске в строке – существует мало текстовых форматов, которые повторяют данные таким образом, – но вскоре обнаруживается, что они *очень* полезны при выполнении строковых подстановок.569570### Незахватывающие и именованные группы571572Сложные регулярные выражения могут использовать много групп как для захвата интересующих подстрок, так и для группировки и структурирования самого выражения. В сложных RE становится трудно отслеживать номера групп. Существуют две возможности, которые помогают решить эту проблему. Обе используют общий синтаксис расширений регулярных выражений, поэтому сначала рассмотрим его.573574Perl 5 хорошо известен своими мощными дополнениями к стандартным регулярным выражениям. Для этих новых возможностей разработчики Perl не могли выбрать новые метасимволы из одного символа или новые специальные последовательности, начинающиеся с `\`, не сделав регулярные выражения Perl запутанно отличающимися от стандартных RE. Если бы они выбрали `&` в качестве нового метасимвола, например, старые выражения предполагали бы, что `&` – это обычный символ, и не экранировали бы его, записывая `\&` или `[&]`.575576Разработчики Perl выбрали `(?...)` в качестве синтаксиса расширения. `?` сразу после круглой скобки был синтаксической ошибкой, потому что `?` нечего было бы повторять, так что это не вызвало проблем совместимости. Символы сразу после `?` указывают, какое расширение используется, так что `(?=foo)` – это одно (положительная опережающая проверка), а `(?:foo)` – другое (незахватывающая группа, содержащая подвыражение `foo`).577578Python поддерживает несколько расширений Perl и добавляет собственный синтаксис расширений к синтаксису расширений Perl. Если первый символ после вопросительного знака – `P`, то это расширение, специфичное для Python.579580Теперь, когда мы рассмотрели общий синтаксис расширений, можно вернуться к возможностям, упрощающим работу с группами в сложных RE.581582Иногда требуется использовать группу для обозначения части регулярного выражения, но нет необходимости извлекать содержимое группы. Это можно явно указать с помощью незахватывающей группы: `(?:...)`, где `...` можно заменить любым другим регулярным выражением.583584```python585>>> m = re.match("([abc])+", "abc")586>>> m.groups()587('c',)588>>> m = re.match("(?:[abc])+", "abc")589>>> m.groups()590()591```592593За исключением того, что нельзя извлечь содержимое того, что сопоставила группа, незахватывающая группа ведёт себя точно так же, как захватывающая: в неё можно поместить что угодно, повторить её с помощью метасимвола повторения, такого как `*`, и вложить в другие группы (захватывающие или незахватывающие). `(?:...)` особенно полезен при изменении существующего шаблона, поскольку можно добавлять новые группы, не меняя нумерацию всех остальных групп. Стоит упомянуть, что нет разницы в производительности поиска между захватывающими и незахватывающими группами; ни одна из форм не быстрее другой.594595Более значимая возможность – именованные группы: вместо обращения по номерам группы можно ссылаться по имени.596597Синтаксис именованной группы – одно из расширений, специфичных для Python: `(?P<name>...)`. *name* – это, очевидно, имя группы. Именованные группы ведут себя точно так же, как захватывающие, и дополнительно связывают имя с группой. Методы [объекта match](https://python-all.ru/3.5/library/re.html#match-objects), которые работают с захватывающими группами, принимают как целые числа, обозначающие группу по номеру, так и строки, содержащие имя нужной группы. Именованные группы по-прежнему имеют номера, поэтому информацию о группе можно получить двумя способами:598599```python600>>> p = re.compile(r'(?P<word>\b\w+\b)')601>>> m = p.search( '(((( Lots of punctuation )))' )602>>> m.group('word')603'Lots'604>>> m.group(1)605'Lots'606```607608Именованные группы удобны, поскольку позволяют использовать легко запоминающиеся имена вместо запоминания номеров. Вот пример RE из модуля [`imaplib`](https://python-all.ru/3.5/library/imaplib.html#module-imaplib):609610```python611InternalDate = re.compile(r'INTERNALDATE "'612        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'613        r'(?P<year>[0-9][0-9][0-9][0-9])'614        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'615        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'616        r'"')617```618619Очевидно, что гораздо проще получить `m.group('zonem')`, чем запоминать, что нужно получить группу 9.620621Синтаксис обратных ссылок в выражении, таком как `(...)\1`, относится к номеру группы. Естественно, существует вариант, использующий имя группы вместо номера. Это ещё одно расширение Python: `(?P=name)` указывает, что содержимое группы с именем *name* должно снова совпадать в текущей позиции. Регулярное выражение для поиска удвоенных слов, `(\b\w+)\s+\1`, можно также записать как `(?P<word>\b\w+)\s+(?P=word)`:622623```python624>>> p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)')625>>> p.search('Paris in the the spring').group()626'the the'627```628629### Опережающие проверки630631Ещё одна проверка нулевой ширины – опережающая проверка. Опережающие проверки бывают положительными и отрицательными и выглядят так:632633**`(?=...)`**634635Положительная опережающая проверка. Она успешна, если вложенное регулярное выражение, представленное здесь как636637`...`638639, успешно совпадает в текущей позиции, и неуспешна в противном случае. Но как только вложенное выражение проверено, движок сопоставления не продвигается; остальная часть шаблона проверяется прямо с того места, где началась проверка.640641**`(?!...)`**642643Отрицательная опережающая проверка. Это противоположность положительной проверке; она успешна, если вложенное выражение644645*не*646647совпадает в текущей позиции строки.648649Чтобы сделать это конкретным, рассмотрим случай, где опережающая проверка полезна. Рассмотрим простой шаблон для сопоставления имени файла и разделения его на базовое имя и расширение, разделённых точкой `.`. Например, в `news.rc` `news` – это базовое имя, а `rc` – расширение файла.650651Шаблон для сопоставления этого довольно прост:652653`.*[.].*$`654655Обратите внимание, что `.` нужно обрабатывать особым образом, потому что это метасимвол, поэтому он помещён в символьный класс, чтобы сопоставлять только этот конкретный символ. Также обратите внимание на завершающий `$`; он добавлен, чтобы гарантировать, что вся оставшаяся часть строки входит в расширение. Это регулярное выражение сопоставляется с `foo.bar`, `autoexec.bat`, `sendmail.cf` и `printers.conf`.656657Теперь усложним задачу: что, если нужно сопоставить имена файлов, расширение которых не равно `bat`? Некоторые неверные попытки:658659`.*[.][^b].*$` Первая попытка выше пытается исключить `bat`, требуя, чтобы первый символ расширения не был `b`. Это неправильно, потому что шаблон также не соответствует `foo.bar`.660661`.*[.]([^b]..|.[^a].|..[^t])$`662663Выражение становится более запутанным, если попытаться исправить первое решение, потребовав совпадения одного из следующих случаев: первый символ расширения не `b`; второй символ не `a`; или третий символ не `t`. Это принимает `foo.bar` и отвергает `autoexec.bat`, но требует трёхбуквенного расширения и не принимает имя файла с двухбуквенным расширением, например `sendmail.cf`. Мы снова усложним шаблон, пытаясь это исправить.664665`.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$`666667В третьей попытке вторая и третья буквы сделаны необязательными, чтобы разрешить сопоставление расширений короче трёх символов, например `sendmail.cf`.668669Шаблон становится очень сложным, что затрудняет его чтение и понимание. Хуже того, если задача изменится и потребуется исключить как `bat`, так и `exe` в качестве расширений, шаблон станет ещё более запутанным и сложным.670671Отрицательная опережающая проверка разрешает всю эту путаницу:672673`.*[.](?!bat$)[^.]*$` Отрицательная опережающая проверка означает: если выражение `bat` не совпадает в этой точке, попробуйте оставшуюся часть шаблона; если `bat$` совпадает, весь шаблон не сработает. Замыкающий `$` требуется, чтобы гарантировать, что нечто вроде `sample.batch`, где расширение начинается только с `bat`, будет разрешено. `[^.]*` гарантирует, что шаблон работает, когда в имени файла есть несколько точек.674675Исключить другое расширение файла теперь легко: просто добавьте его как альтернативу внутри проверки. Следующий шаблон исключает имена файлов, которые заканчиваются на `bat` или `exe`:676677`.*[.](?!bat$|exe$)[^.]*$`678679## Изменение строк680681До этого момента мы просто выполняли поиск в статической строке. Регулярные выражения также часто используются для изменения строк различными способами с помощью следующих методов шаблона:682683| Метод/Атрибут | Назначение |684| --- | --- |685| `split()` | Разделяет строку на список, разбивая её везде, где совпадает RE |686| `sub()` | Находит все подстроки, совпадающие с RE, и заменяет их на другую строку |687| `subn()` | Делает то же самое, что `sub()`, но возвращает новую строку и количество замен |688689### Разделение строк690691Метод `split()` шаблона разделяет строку везде, где совпадает RE, возвращая список частей. Он похож на метод `split()` строк, но предоставляет гораздо большую гибкость в разделителях, по которым можно разбивать; строковый `split()` поддерживает разбиение только по пробельным символам или по фиксированной строке. Как и следовало ожидать, существует также функция уровня модуля [`re.split()`](https://python-all.ru/3.5/library/re.html#re.split).692693#### `.split(string[, maxsplit=0])`694695Разделяет *строку* по совпадениям регулярного выражения. Если в RE используются захватывающие круглые скобки, то их содержимое также будет возвращено как часть результирующего списка. Если *maxsplit* не равно нулю, выполняется не более *maxsplit* разбиений.696697Количество выполняемых разбиений можно ограничить, передав значение для *maxsplit*. Если *maxsplit* не равно нулю, будет выполнено не более *maxsplit* разбиений, а остаток строки возвращается как последний элемент списка. В следующем примере разделителем является любая последовательность неалфавитно-цифровых символов.698699```python700>>> p = re.compile(r'\W+')701>>> p.split('This is a test, short and sweet, of split().')702['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']703>>> p.split('This is a test, short and sweet, of split().', 3)704['This', 'is', 'a', 'test, short and sweet, of split().']705```706707Иногда нужно знать не только текст между разделителями, но и сам разделитель. Если в RE используются захватывающие круглые скобки, то их значения также возвращаются как часть списка. Сравните следующие вызовы:708709```python710>>> p = re.compile(r'\W+')711>>> p2 = re.compile(r'(\W+)')712>>> p.split('This... is a test.')713['This', 'is', 'a', 'test', '']714>>> p2.split('This... is a test.')715['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']716```717718Функция уровня модуля [`re.split()`](https://python-all.ru/3.5/library/re.html#re.split) добавляет RE, используемый как первый аргумент, но в остальном идентична.719720```python721>>> re.split('[\W]+', 'Words, words, words.')722['Words', 'words', 'words', '']723>>> re.split('([\W]+)', 'Words, words, words.')724['Words', ', ', 'words', ', ', 'words', '.', '']725>>> re.split('[\W]+', 'Words, words, words.', 1)726['Words', 'words, words.']727```728729### Поиск и замена730731Ещё одна распространённая задача – найти все совпадения с шаблоном и заменить их другой строкой. Метод `sub()` принимает значение замены, которое может быть строкой или функцией, и обрабатываемую строку.732733#### `.sub(replacement, string[, count=0])`734735Возвращает строку, полученную заменой самых левых непересекающихся совпадений RE в *строке* на замену *replacement*. Если шаблон не найден, *строка* возвращается без изменений.736737Необязательный аргумент *count* – максимальное количество заменяемых вхождений шаблона; *count* должно быть неотрицательным целым числом. Значение по умолчанию 0 означает замену всех вхождений.738739Вот простой пример использования метода `sub()`. Он заменяет названия цветов словом `colour`:740741```python742>>> p = re.compile('(blue|white|red)')743>>> p.sub('colour', 'blue socks and red shoes')744'colour socks and colour shoes'745>>> p.sub('colour', 'blue socks and red shoes', count=1)746'colour socks and red shoes'747```748749Метод `subn()` делает то же самое, но возвращает кортеж из двух элементов, содержащий новую строку и количество выполненных замен:750751```python752>>> p = re.compile('(blue|white|red)')753>>> p.subn('colour', 'blue socks and red shoes')754('colour socks and colour shoes', 2)755>>> p.subn('colour', 'no colours at all')756('no colours at all', 0)757```758759Пустые совпадения заменяются только тогда, когда они не примыкают к предыдущему совпадению.760761```python762>>> p = re.compile('x*')763>>> p.sub('-', 'abxd')764'-a-b-d-'765```766767Если *replacement* является строкой, все escape-последовательности с обратной косой чертой обрабатываются. То есть `\n` преобразуется в символ новой строки, `\r` – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как `\&`, остаются без изменений. Обратные ссылки, например `\6`, заменяются подстрокой, совпавшей с соответствующей группой в регулярном выражении. Это позволяет включать части исходного текста в результирующую строку замены.768769В этом примере ищется слово `section`, за которым следует строка, заключённая в `{`, `}`, и `section` заменяется на `subsection`:770771```python772>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)773>>> p.sub(r'subsection{\1}','section{First} section{second}')774'subsection{First} subsection{second}'775```776777Существует также синтаксис для ссылки на именованные группы, определённые с помощью синтаксиса `(?P<name>...)`. `\g<name>` будет использовать подстроку, совпавшую с группой с именем `name`, а `\g<number>` использует соответствующий номер группы. Таким образом, `\g<2>` эквивалентно `\2`, но не является неоднозначным в строке замены, такой как `\g<2>0`. (`\20` было бы интерпретировано как ссылка на группу 20, а не как ссылка на группу 2, за которой следует литеральный символ `'0'`.) Следующие подстановки эквивалентны, но используют все три варианта строки замены.778779```python780>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)781>>> p.sub(r'subsection{\1}','section{First}')782'subsection{First}'783>>> p.sub(r'subsection{\g<1>}','section{First}')784'subsection{First}'785>>> p.sub(r'subsection{\g<name>}','section{First}')786'subsection{First}'787```788789*replacement* также может быть функцией, что даёт ещё больше контроля. Если *replacement* является функцией, она вызывается для каждого непересекающегося вхождения *pattern*. При каждом вызове функции передаётся аргумент [объект совпадения](https://python-all.ru/3.5/library/re.html#match-objects) и она может использовать эту информацию для вычисления нужной строки замены и возврата её.790791В следующем примере функция замены преобразует десятичные числа в шестнадцатеричные:792793```python794>>> def hexrepl(match):795...     "Return the hex string for a decimal number"796...     value = int(match.group())797...     return hex(value)798...799>>> p = re.compile(r'\d+')800>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')801'Call 0xffd2 for printing, 0xc000 for user code.'802```803804При использовании функции уровня модуля [`re.sub()`](https://python-all.ru/3.5/library/re.html#re.sub) шаблон передаётся как первый аргумент. Шаблон может быть предоставлен как объект или как строка; если нужно указать флаги регулярного выражения, необходимо либо использовать объект шаблона в качестве первого параметра, либо использовать встроенные модификаторы в строке шаблона, например `sub("(?i)b+", "x", "bbbb BBBB")` возвращает `'x x'`.805806## Распространенные проблемы807808Регулярные выражения – мощный инструмент для некоторых приложений, но в некоторых аспектах их поведение не интуитивно и иногда они ведут себя не так, как можно было бы ожидать. В этом разделе будут указаны некоторые наиболее распространённые ошибки.809810### Применение строковых методов811812Иногда использование модуля [`re`](https://python-all.ru/3.5/library/re.html#module-re) является ошибкой. Если производится сопоставление с фиксированной строкой или одиночным классом символов и не используются никакие возможности [`re`](https://python-all.ru/3.5/library/re.html#module-re), такие как флаг `IGNORECASE`, то вся мощь регулярных выражений может не понадобиться. Строки имеют несколько методов для выполнения операций с фиксированными строками, и они обычно намного быстрее, поскольку реализация представляет собой один небольшой цикл на C, оптимизированный для этой цели, а не большой, более обобщённый движок регулярных выражений.813814Примером может быть замена одной фиксированной строки на другую; например, можно заменить `word` на `deed`. `re.sub()` кажется подходящей функцией для этого, но рассмотрите метод `replace()`. Обратите внимание, что `replace()` также заменит `word` внутри слов, превратив `swordfish` в `sdeedfish`, но наивное RE `word` сделало бы то же самое. (Чтобы избежать замены в частях слов, шаблон должен быть `\bword\b`, чтобы требовать, чтобы `word` имело границу слова с обеих сторон. Это выходит за рамки возможностей `replace()`.)815816Ещё одна распространённая задача – удаление всех вхождений одного символа из строки или замена его другим символом. Можно сделать это с помощью чего-то вроде `re.sub('\n', ' ', S)`, но `translate()` способен выполнить обе задачи и будет быстрее любой операции с регулярными выражениями.817818Короче говоря, прежде чем обращаться к модулю [`re`](https://python-all.ru/3.5/library/re.html#module-re), подумайте, не решается ли ваша задача более быстрым и простым строковым методом.819820### match() и search()821822Функция `match()` проверяет совпадение только в начале строки, тогда как `search()` просматривает строку в поисках совпадения. Важно помнить об этом различии. Помните: `match()` сообщит об успешном совпадении, только если оно начинается с 0; если совпадение начинается не с нуля, `match()` *не* сообщит о нём.823824```python825>>> print(re.match('super', 'superstition').span())826(0, 5)827>>> print(re.match('super', 'insuperable'))828None829```830831С другой стороны, `search()` будет просматривать строку и сообщать о первом найденном совпадении.832833```python834>>> print(re.search('super', 'superstition').span())835(0, 5)836>>> print(re.search('super', 'insuperable').span())837(2, 7)838```839840Иногда возникает соблазн продолжать использовать [`re.match()`](https://python-all.ru/3.5/library/re.html#re.match) и просто добавлять `.*` в начало RE. Сопротивляйтесь этому соблазну и используйте [`re.search()`](https://python-all.ru/3.5/library/re.html#re.search). Компилятор регулярных выражений выполняет некоторый анализ RE, чтобы ускорить процесс поиска совпадения. Один из таких анализов определяет, каким должен быть первый символ совпадения; например, шаблон, начинающийся с `Crow`, должен совпадать с `'C'`. Анализ позволяет движку быстро просматривать строку в поисках начального символа, пробуя полное совпадение только если найден `'C'`.841842Добавление `.*` сводит на нет эту оптимизацию, требуя сканирования до конца строки и последующего возврата для поиска совпадения для остальной части RE. Используйте [`re.search()`](https://python-all.ru/3.5/library/re.html#re.search) вместо этого.843844### Жадный и нежадный режимы845846При повторении регулярного выражения, как в `a*`, результатом является потребление как можно большей части шаблона. Этот факт часто подводит, когда пытаются сопоставить пару сбалансированных разделителей, например, угловые скобки, окружающие HTML-тег. Наивный шаблон для сопоставления одного HTML-тега не работает из-за жадной природы `.*`.847848```python849>>> s = '<html><head><title>Title</title>'850>>> len(s)85132852>>> print(re.match('<.*>', s).span())853(0, 32)854>>> print(re.match('<.*>', s).group())855<html><head><title>Title</title>856```857858RE находит `'<'` в `<html>`, а `.*` поглощает остаток строки. Однако в RE остаётся ещё часть, и `>` не может совпасть в конце строки, поэтому движку регулярных выражений приходится возвращаться посимвольно, пока он не найдёт совпадение для `>`. Итоговое совпадение простирается от `'<'` в `<html>` до `'>'` в `</title>`, что не то, что нужно.859860В этом случае решение – использовать нежадные квантификаторы `*?`, `+?`, `??` или `{m,n}?`, которые захватывают как *мало* текста, насколько это возможно. В приведённом выше примере `'>'` проверяется сразу после совпадения первого `'<'`, и когда это не удаётся, движок продвигается на один символ, заново проверяя `'>'` на каждом шаге. Это даёт правильный результат:861862```python863>>> print(re.match('<.*?>', s).group())864<html>865```866867(Заметьте, что разбор HTML или XML с помощью регулярных выражений – дело мучительное. Быстрые и грязные шаблоны справятся с обычными случаями, но у HTML и XML есть особые случаи, которые сломают очевидное регулярное выражение; к тому времени, как вы напишете регулярное выражение, обрабатывающее все возможные случаи, шаблоны станут *очень* сложными. Используйте для таких задач модуль разбора HTML или XML.)868869### Использование re.VERBOSE870871К этому моменту вы, вероятно, заметили, что регулярные выражения – это очень компактная запись, но они не слишком читаемы. RE умеренной сложности могут превратиться в длинные наборы обратных слешей, скобок и метасимволов, что затрудняет их чтение и понимание.872873Для таких RE указание флага `re.VERBOSE` при компиляции регулярного выражения может быть полезно, поскольку позволяет форматировать регулярное выражение более чётко.874875Флаг `re.VERBOSE` имеет несколько эффектов. Пробельные символы в регулярном выражении, которые *не находятся* внутри символьного класса, игнорируются. Это означает, что выражение вида `dog | cat` эквивалентно менее читаемому `dog|cat`, но `[a b]` по-прежнему будет соответствовать символам `'a'`, `'b'` или пробелу. Кроме того, в RE можно вставлять комментарии; комментарии начинаются с символа `#` и продолжаются до следующей новой строки. При использовании с тройными кавычками это позволяет форматировать RE более аккуратно:876877```python878pat = re.compile(r"""879 \s*                 # Skip leading whitespace880 (?P<header>[^:]+)   # Header name881 \s* :               # Whitespace, and a colon882 (?P<value>.*?)      # The header's value -- *? used to883                     # lose the following trailing whitespace884 \s*$                # Trailing whitespace to end-of-line885""", re.VERBOSE)886```887888Это гораздо читаемее, чем:889890```python891pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")892```893894## Обратная связь895896Регулярные выражения – сложная тема. Помог ли вам этот документ понять их? Были ли части, которые остались неясными, или проблемы, с которыми вы столкнулись и которые не были здесь рассмотрены? Если да, отправьте предложения по улучшению автору.897898Наиболее полной книгой по регулярным выражениям, пожалуй, является \*Mastering Regular Expressions\* Джеффри Фридла, издательство O’Reilly. К сожалению, она сосредоточена исключительно на разновидностях регулярных выражений Perl и Java и вообще не содержит материала по Python, так что она не пригодится в качестве справочника по программированию на Python. (В первом издании рассматривался модуль `regex`, который теперь удалён из Python, что вам не сильно поможет.) Рекомендуем взять её в библиотеке.899