regex.md

1> **Источник:** https://python-all.ru/3.7/howto/regex.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# Регулярные выражения: руководство89**Автор**1011A.M. Kuchling \<[amk@amk.ca](https://python-all.ru/3.7/howto/regex.html)\>1213Аннотация1415Этот документ – вводное руководство по использованию регулярных выражений в Python с модулем [`re`](https://python-all.ru/3.7/library/re.html#module-re). Оно даёт более плавное введение, чем соответствующий раздел в справочнике по библиотеке.1617## Введение1819Регулярные выражения (называемые RE, или regex, или regex-шаблоны) – это, по сути, крошечный, узкоспециализированный язык программирования, встроенный в Python и доступный через модуль [`re`](https://python-all.ru/3.7/library/re.html#module-re). С помощью этого небольшого языка вы задаёте правила для множества возможных строк, которые хотите сопоставить; это множество может содержать английские предложения, адреса электронной почты, команды TeX или что угодно. Затем можно задавать вопросы вроде «Соответствует ли эта строка шаблону?» или «Есть ли совпадение с шаблоном где-либо в этой строке?». С помощью RE можно также изменять строку или разделять её различными способами.2021Шаблоны регулярных выражений компилируются в набор байткодов, которые затем выполняются механизмом сопоставления, написанным на C. Для продвинутого использования может потребоваться тщательно следить за тем, как механизм будет выполнять данное RE, и писать RE определённым образом, чтобы получить байткод, работающий быстрее. Оптимизация не рассматривается в этом документе, поскольку она требует хорошего понимания внутреннего устройства механизма сопоставления.2223Язык регулярных выражений относительно мал и ограничен, поэтому не все задачи обработки строк можно решить с помощью регулярных выражений. Существуют также задачи, которые *можно* выполнить с помощью регулярных выражений, но выражения оказываются очень сложными. В таких случаях, возможно, лучше написать код на Python для обработки; хотя код на Python будет медленнее, чем сложное регулярное выражение, он, вероятно, будет более понятным.2425## Простые шаблоны2627Начнём с изучения самых простых регулярных выражений. Поскольку регулярные выражения используются для работы со строками, начнём с самой распространённой задачи: сопоставления символов.2829Подробное объяснение теоретических основ регулярных выражений (детерминированные и недетерминированные конечные автоматы) можно найти почти в любом учебнике по написанию компиляторов.3031### Сопоставление символов3233Большинство букв и символов сопоставляются сами с собой. Например, регулярное выражение `test` будет точно соответствовать строке `test`. (Можно включить регистронезависимый режим, который позволит этому РВ сопоставляться также с `Test` или `TEST`; подробнее об этом позже.)3435Из этого правила есть исключения: некоторые символы являются специальными *метасимволами* и не сопоставляются сами с собой. Вместо этого они указывают, что должно быть сопоставлено что-то необычное, или влияют на другие части РВ, повторяя их или меняя их значение. Значительная часть этого документа посвящена обсуждению различных метасимволов и их действий.3637Вот полный список метасимволов; их значения будут рассмотрены в остальной части этого HOWTO.3839```text40. ^ $ * + ? { } [ ] \ | ( )41```4243Первые метасимволы, которые мы рассмотрим, – это `[` и `]`. Они используются для определения символьного класса – набора символов, которые нужно сопоставить. Символы можно перечислить по отдельности, или указать диапазон символов, задав два символа и разделив их дефисом `'-'`. Например, `[abc]` будет соответствовать любому из символов `a`, `b` или `c`; это то же самое, что `[a-c]`, где диапазон выражает тот же набор символов. Если нужно сопоставлять только строчные буквы, РВ будет `[a-z]`.4445Метасимволы не активны внутри классов. Например, `[akm$]` будет соответствовать любому из символов `'a'`, `'k'`, `'m'` или `'$'`; `'$'` обычно является метасимволом, но внутри символьного класса он лишается своего особого значения.4647Можно сопоставлять символы, не входящие в класс, *дополняя* набор. Это обозначается включением `'^'` в качестве первого символа класса. Например, `[^5]` будет соответствовать любому символу, кроме `'5'`. Если символ крышки (^) появляется в другом месте символьного класса, он не имеет специального значения. Например: `[5^]` будет соответствовать либо `'5'`, либо `'^'`.4849Пожалуй, самый важный метасимвол – обратная косая черта, `\`. Как и в строковых литералах Python, за обратной косой чертой могут следовать различные символы для обозначения специальных последовательностей. Она также используется для экранирования всех метасимволов, чтобы их можно было сопоставлять в шаблонах; например, если нужно сопоставить `[` или `\`, можно поставить перед ними обратную косую черту, чтобы убрать их специальное значение: `\[` или `\\`.5051Некоторые специальные последовательности, начинающиеся с `'\'`, представляют предопределённые наборы символов, которые часто бывают полезны: например, набор цифр, набор букв или набор всего, что не является пробельным символом.5253Рассмотрим пример: `\w` соответствует любому буквенно-цифровому символу. Если шаблон регулярного выражения задан в байтах, это эквивалентно классу `[a-zA-Z0-9_]`. Если шаблон – строка, `\w` будет соответствовать всем символам, помеченным как буквы в базе данных Unicode, которую предоставляет модуль [`unicodedata`](https://python-all.ru/3.7/library/unicodedata.html#module-unicodedata). Можно использовать более ограниченное определение `\w` в строковом шаблоне, указав флаг [`re.ASCII`](https://python-all.ru/3.7/library/re.html#re.ASCII) при компиляции регулярного выражения.5455Следующий список специальных последовательностей неполон. Полный список последовательностей и расширенных определений классов для строковых шаблонов Unicode см. в последней части [Синтаксис регулярных выражений](https://python-all.ru/3.7/library/re.html#re-syntax) в справочнике стандартной библиотеки. В общем, версии Unicode соответствуют любому символу, находящемуся в соответствующей категории в базе данных Unicode.5657**`\d`**5859Соответствует любой десятичной цифре; эквивалентно классу `[0-9]`.6061**`\D`**6263Соответствует любому нецифровому символу; эквивалентно классу `[^0-9]`.6465**`\s`**6667Соответствует любому пробельному символу; эквивалентно классу `[ \t\n\r\f\v]`.6869**`\S`**7071Соответствует любому непробельному символу; эквивалентно классу `[^ \t\n\r\f\v]`.7273**`\w`**7475Соответствует любому буквенно-цифровому символу; эквивалентно классу `[a-zA-Z0-9_]`.7677**`\W`**7879Соответствует любому не буквенно-цифровому символу; эквивалентно классу `[^a-zA-Z0-9_]`.8081Эти последовательности можно включать внутрь символьного класса. Например, `[\s,.]` – это символьный класс, который будет соответствовать любому пробельному символу, или `','`, или `'.'`.8283Последний метасимвол в этом разделе – `.`. Он соответствует любому символу, кроме символа новой строки, и есть альтернативный режим ([`re.DOTALL`](https://python-all.ru/3.7/library/re.html#re.DOTALL)), в котором он будет соответствовать даже новой строке. `.` часто используется, когда нужно сопоставить «любой символ».8485### Повторяющиеся элементы8687Возможность сопоставлять различные наборы символов – это первое, что регулярные выражения умеют делать, чего уже нельзя сделать с помощью методов строк. Однако если бы это была единственная дополнительная возможность регулярных выражений, они не были бы большим достижением. Ещё одна возможность – указывать, что части РВ должны повторяться определённое количество раз.8889Первый метасимвол для повторения, который мы рассмотрим, – это `*`. `*` не соответствует литеральному символу `'*'`; вместо этого он указывает, что предыдущий символ может быть сопоставлен ноль или более раз, а не ровно один раз.9091Например, `ca*t` будет соответствовать `'ct'` (0 символов `'a'`), `'cat'` (1 символ `'a'`), `'caaat'` (3 символа `'a'`) и так далее.9293Повторения, такие как `*`, являются *жадными*; при повторении РВ движок сопоставления будет стараться повторить его как можно больше раз. Если более поздние части шаблона не совпадают, движок сопоставления отступает и пробует снова с меньшим числом повторений.9495Пошаговый пример прояснит это. Рассмотрим выражение `a[bcd]*b`. Оно соответствует букве `'a'`, нулю или более букв из класса `[bcd]` и заканчивается символом `'b'`. Теперь представим, что это РВ сопоставляется со строкой `'abcbd'`.9697| Шаг | Совпадение | Пояснение |98| --- | --- | --- |99| 1 | `a` | `a` в РВ совпадает. |100| 2 | `abcbd` | Движок сопоставляет `[bcd]*`, продвигаясь так далеко, как может, то есть до конца строки. |101| 3 | *Неудача* | Движок пытается сопоставить `b`, но текущая позиция находится в конце строки, поэтому попытка не удаётся. |102| 4 | `abcb` | Отступ, чтобы `[bcd]*` сопоставляло на один символ меньше. |103| 5 | *Неудача* | Снова попробовать `b`, но текущая позиция находится на последнем символе, которым является `'d'`. |104| 6 | `abc` | Снова отступ, чтобы `[bcd]*` сопоставляло только `bc`. |105| 6 | `abcb` | Снова попробовать `b`. На этот раз символ в текущей позиции – `'b'`, поэтому совпадение находится. |106107Конец регулярного выражения достигнут, и оно сопоставило `'abcb'`. Это показывает, как движок сопоставления сначала заходит так далеко, как может, а если совпадение не найдено, постепенно отступает и снова и снова перебирает остальную часть регулярного выражения. Он будет отступать до тех пор, пока не попробует ноль совпадений для `[bcd]*`, и если это впоследствии не удастся, движок приходит к выводу, что строка вообще не соответствует регулярному выражению.108109Ещё один повторяющийся метасимвол – `+`, который совпадает один или более раз. Обратите внимание на разницу между `*` и `+`; `*` совпадает *ноль* или более раз, так что повторяемый элемент может отсутствовать вовсе, тогда как `+` требует как минимум *одного* вхождения. Для похожего примера `ca+t` будет совпадать с `'cat'` (1 `'a'`), `'caaat'` (3 `'a'`), но не совпадёт с `'ct'`.110111Есть ещё два повторяющихся квантификатора. Символ вопросительного знака `?`, соответствует одному или нулю повторений; его можно считать пометкой чего-либо как необязательного. Например, `home-?brew` соответствует либо `'homebrew'`, либо `'home-brew'`.112113Самый сложный повторяющийся квантификатор – `{m,n}`, где *m* и *n* – десятичные целые числа. Этот квантификатор означает, что должно быть как минимум *m* повторений и как максимум *n*. Например, `a/{1,3}b` соответствует `'a/b'`, `'a//b'` и `'a///b'`. Он не соответствует `'ab'` (без слэшей) или `'a////b'` (с четырьмя).114115Можно опустить либо *m*, либо *n*; в этом случае для отсутствующего значения используется разумное значение по умолчанию. Пропуск *m* интерпретируется как нижняя граница 0, а пропуск *n* даёт верхнюю границу бесконечность.116117Можно заметить, что три остальных квантификатора можно выразить через эту нотацию. `{0,}` – то же, что `*`, `{1,}` эквивалентен `+`, а `{0,1}` – то же, что `?`. Лучше использовать `*`, `+` или `?`, когда это возможно, просто потому что они короче и легче читаются.118119## Использование регулярных выражений120121Теперь, когда мы рассмотрели некоторые простые регулярные выражения, как же их использовать в Python? Модуль [`re`](https://python-all.ru/3.7/library/re.html#module-re) предоставляет интерфейс к движку регулярных выражений, позволяя компилировать регулярные выражения в объекты и затем выполнять с ними сопоставление.122123### Компиляция регулярных выражений124125Регулярные выражения компилируются в объекты шаблонов, которые имеют методы для различных операций, таких как поиск совпадений с шаблоном или выполнение подстановок в строке.126127```python128>>> import re129>>> p = re.compile('ab*')130>>> p131re.compile('ab*')132```133134[`re.compile()`](https://python-all.ru/3.7/library/re.html#re.compile) также принимает необязательный аргумент *flags*, используемый для включения различных специальных возможностей и вариантов синтаксиса. Мы рассмотрим доступные настройки позже, а пока достаточно одного примера:135136```python137>>> p = re.compile('ab*', re.IGNORECASE)138```139140RE передаётся в [`re.compile()`](https://python-all.ru/3.7/library/re.html#re.compile) в виде строки. RE обрабатываются как строки, поскольку регулярные выражения не являются частью ядра языка Python, и для их записи не был создан специальный синтаксис. (Существуют приложения, которым RE вообще не нужны, поэтому нет необходимости раздувать спецификацию языка, включая их.) Вместо этого модуль [`re`](https://python-all.ru/3.7/library/re.html#module-re) – это просто модуль-расширение на C, поставляемый с Python, точно так же, как модули [`socket`](https://python-all.ru/3.7/library/socket.html#module-socket) или [`zlib`](https://python-all.ru/3.7/library/zlib.html#module-zlib).141142Размещение RE в строках сохраняет язык Python более простым, но имеет один недостаток, который является темой следующего раздела.143144### Проблема обратной косой черты145146Как было сказано ранее, регулярные выражения используют символ обратной косой черты (`'\'`) для обозначения специальных форм или для использования специальных символов без их специального значения. Это конфликтует с использованием того же символа в строковых литералах Python для той же цели.147148Допустим, нужно написать RE, которое бы совпадало со строкой `\section`, которая может встретиться в файле LaTeX. Чтобы понять, что написать в коде программы, начнём с желаемой строки для совпадения. Затем необходимо экранировать все обратные слеши и другие метасимволы, поставив перед ними обратную косую черту, в результате получится строка `\\section`. Итоговая строка, которую нужно передать в [`re.compile()`](https://python-all.ru/3.7/library/re.html#re.compile), должна быть `\\section`. Однако, чтобы представить это в виде строкового литерала Python, оба обратных слеша нужно экранировать *снова*.149150| Символы | Этап |151| --- | --- |152| `\section` | Строка для совпадения |153| `\\section` | Экранированный обратный слеш для [`re.compile()`](https://python-all.ru/3.7/library/re.html#re.compile) |154| `"\\\\section"` | Экранированные обратные слеши для строкового литерала |155156Короче говоря, для сопоставления с литералом обратной косой черты нужно записать `'\\\\'` в качестве строки RE, потому что регулярное выражение должно быть `\\`, а каждый обратный слеш должен быть представлен как `\\` внутри обычного строкового литерала Python. В RE, где обратные слеши встречаются многократно, это приводит к множеству повторных слешей и делает итоговые строки трудными для понимания.157158Решение – использовать сырые строки Python для регулярных выражений; обратные слеши не обрабатываются особым образом в строковом литерале с префиксом `'r'`, поэтому `r"\n"` – это двухсимвольная строка, содержащая `'\'` и `'n'`, а `"\n"` – односимвольная строка, содержащая перевод строки. Регулярные выражения часто записываются в коде Python с использованием этой сырой строковой записи.159160Кроме того, специальные escape-последовательности, которые допустимы в регулярных выражениях, но не допустимы как строковые литералы Python, теперь приводят к [`DeprecationWarning`](https://python-all.ru/3.7/library/exceptions.html#DeprecationWarning) и со временем станут [`SyntaxError`](https://python-all.ru/3.7/library/exceptions.html#SyntaxError), то есть последовательности будут недействительны, если не использовать сырые строки или экранирование обратных косых черт.161162| Обычная строка | Сырая строка |163| --- | --- |164| `"ab*"` | `r"ab*"` |165| `"\\\\section"` | `r"\\section"` |166| `"\\w+\\s+\\1"` | `r"\w+\s+\1"` |167168### Выполнение поиска совпадений169170Как только у вас есть объект, представляющий скомпилированное регулярное выражение, что с ним делать? Объекты Pattern имеют несколько методов и атрибутов. Здесь будут рассмотрены только самые важные; за полным списком обращайтесь к документации [`re`](https://python-all.ru/3.7/library/re.html#module-re).171172| Метод/Атрибут | Назначение |173| --- | --- |174| `match()` | Определяет, совпадает ли RE в начале строки. |175| `search()` | Сканирует строку в поисках любого места, где данное регулярное выражение совпадает. |176| `findall()` | Находит все подстроки, совпадающие с регулярным выражением, и возвращает их в виде списка. |177| `finditer()` | Find all substrings where the RE matches, and returns them as an [iterator](https://python-all.ru/3.7/glossary.html#term-iterator). |178179[`match()`](https://python-all.ru/3.7/library/re.html#re.Pattern.match) и [`search()`](https://python-all.ru/3.7/library/re.html#re.Pattern.search) возвращают `None`, если совпадение не найдено. В случае успеха возвращается экземпляр [объекта совпадения](https://python-all.ru/3.7/library/re.html#match-objects), содержащий информацию о совпадении: где оно начинается и заканчивается, совпавшую подстроку и другое.180181Это можно изучить, экспериментируя интерактивно с модулем [`re`](https://python-all.ru/3.7/library/re.html#module-re) Если у вас есть [`tkinter`](https://python-all.ru/3.7/library/tkinter.html#module-tkinter), вы также можете посмотреть [Tools/demo/redemo.py](https://python-all.ru/src/3.7/Tools/demo/redemo.py) – демонстрационную программу, входящую в состав дистрибутива Python. Она позволяет вводить регулярные выражения и строки и показывает, совпадает ли выражение или нет. `redemo.py` может быть весьма полезен при отладке сложных регулярных выражений.182183В данном HOWTO используется стандартный интерпретатор Python для примеров. Сначала запустите интерпретатор Python, импортируйте модуль [`re`](https://python-all.ru/3.7/library/re.html#module-re) и скомпилируйте регулярное выражение:184185```python186>>> import re187>>> p = re.compile('[a-z]+')188>>> p189re.compile('[a-z]+')190```191192Теперь можно попробовать сопоставить различные строки с РВ `[a-z]+`. Пустая строка не должна совпадать, поскольку `+` означает «одно или более повторений». [`match()`](https://python-all.ru/3.7/library/re.html#re.Pattern.match) в этом случае должен вернуть `None`, что заставит интерпретатор ничего не выводить. Можно явно напечатать результат `match()`, чтобы прояснить это.193194```python195>>> p.match("")196>>> print(p.match(""))197None198```199200Теперь попробуем на строке, которая должна совпадать, например `tempo`. В этом случае [`match()`](https://python-all.ru/3.7/library/re.html#re.Pattern.match) вернёт [объект совпадения](https://python-all.ru/3.7/library/re.html#match-objects), так что сохраните результат в переменную для последующего использования.201202```python203>>> m = p.match('tempo')204>>> m205<re.Match object; span=(0, 5), match='tempo'>206```207208Теперь можно запросить у [объекта совпадения](https://python-all.ru/3.7/library/re.html#match-objects) информацию о совпавшей строке. Экземпляры объекта совпадения также имеют несколько методов и атрибутов; наиболее важные:209210| Метод/Атрибут | Назначение |211| --- | --- |212| `group()` | Возвращает строку, совпавшую с РВ |213| `start()` | Возвращает начальную позицию совпадения |214| `end()` | Возвращает конечную позицию совпадения |215| `span()` | Возвращает кортеж с (начало, конец) позициями совпадения |216217Применение этих методов быстро прояснит их смысл:218219```python220>>> m.group()221'tempo'222>>> m.start(), m.end()223(0, 5)224>>> m.span()225(0, 5)226```227228[`group()`](https://python-all.ru/3.7/library/re.html#re.Match.group) возвращает подстроку, совпавшую с RE. [`start()`](https://python-all.ru/3.7/library/re.html#re.Match.start) и [`end()`](https://python-all.ru/3.7/library/re.html#re.Match.end) возвращают начальный и конечный индекс совпадения. [`span()`](https://python-all.ru/3.7/library/re.html#re.Match.span) возвращает оба индекса в одном кортеже. Поскольку метод [`match()`](https://python-all.ru/3.7/library/re.html#re.Pattern.match) проверяет совпадение только в начале строки, `start()` всегда будет равен нулю. Однако метод [`search()`](https://python-all.ru/3.7/library/re.html#re.Pattern.search) шаблонов просматривает строку, поэтому в таком случае совпадение может начинаться не с нуля.229230```python231>>> print(p.match('::: message'))232None233>>> m = p.search('::: message'); print(m)234<re.Match object; span=(4, 11), match='message'>235>>> m.group()236'message'237>>> m.span()238(4, 11)239```240241В реальных программах наиболее распространённый подход – сохранить [объект совпадения](https://python-all.ru/3.7/library/re.html#match-objects) в переменную, а затем проверить, был ли он `None`. Обычно это выглядит так:242243```python244p = re.compile( ... )245m = p.match( 'string goes here' )246if m:247    print('Match found: ', m.group())248else:249    print('No match')250```251252Два метода шаблонов возвращают все совпадения для шаблона. [`findall()`](https://python-all.ru/3.7/library/re.html#re.Pattern.findall) возвращает список совпавших строк:253254```python255>>> p = re.compile(r'\d+')256>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')257['12', '11', '10']258```259260The `r` prefix, making the literal a raw string literal, is needed in this example because escape sequences in a normal “cooked” string literal that are not recognized by Python, as opposed to regular expressions, now result in a [`DeprecationWarning`](https://python-all.ru/3.7/library/exceptions.html#DeprecationWarning) and will eventually become a [`SyntaxError`](https://python-all.ru/3.7/library/exceptions.html#SyntaxError). See [The Backslash Plague](https://python-all.ru/3.7/howto/regex.html#the-backslash-plague).261262[`findall()`](https://python-all.ru/3.7/library/re.html#re.Pattern.findall) должен создать весь список, прежде чем его можно будет вернуть как результат. Метод [`finditer()`](https://python-all.ru/3.7/library/re.html#re.Pattern.finditer) возвращает последовательность экземпляров [объектов совпадения](https://python-all.ru/3.7/library/re.html#match-objects) в виде [итератора](https://python-all.ru/3.7/glossary.html#term-iterator):263264```python265>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')266>>> iterator  267<callable_iterator object at 0x...>268>>> for match in iterator:269...     print(match.span())270...271(0, 2)272(22, 24)273(29, 31)274```275276### Функции уровня модуля277278Необязательно создавать объект шаблона и вызывать его методы; модуль [`re`](https://python-all.ru/3.7/library/re.html#module-re) также предоставляет функции верхнего уровня, называемые [`match()`](https://python-all.ru/3.7/library/re.html#re.match), [`search()`](https://python-all.ru/3.7/library/re.html#re.search), [`findall()`](https://python-all.ru/3.7/library/re.html#re.findall), [`sub()`](https://python-all.ru/3.7/library/re.html#re.sub) и так далее. Эти функции принимают те же аргументы, что и соответствующий метод шаблона, с добавлением строки РВ в качестве первого аргумента, и по-прежнему возвращают либо `None`, либо экземпляр [объекта совпадения](https://python-all.ru/3.7/library/re.html#match-objects).279280```python281>>> print(re.match(r'From\s+', 'Fromage amk'))282None283>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')  284<re.Match object; span=(0, 5), match='From '>285```286287Под капотом эти функции просто создают объект шаблона и вызывают на нём соответствующий метод. Они также сохраняют скомпилированный объект в кеш, так что последующие вызовы с тем же РВ не будут каждый раз разбирать шаблон заново.288289Следует ли использовать функции уровня модуля или получать шаблон и вызывать его методы самостоятельно? При доступе к регулярному выражению внутри цикла предварительная компиляция позволит сэкономить несколько вызовов функций. Вне циклов, благодаря внутреннему кешу, разница невелика.290291### Флаги компиляции292293Флаги компиляции позволяют изменять некоторые аспекты работы регулярных выражений. Флаги доступны в модуле [`re`](https://python-all.ru/3.7/library/re.html#module-re) под двумя именами: длинным, например `IGNORECASE`, и коротким, однобуквенным, например `I`. (Для знакомых с модификаторами шаблонов Perl: однобуквенные формы используют те же буквы; например, короткая форма [`re.VERBOSE`](https://python-all.ru/3.7/library/re.html#re.VERBOSE) – это [`re.X`](https://python-all.ru/3.7/library/re.html#re.X).) Несколько флагов можно указать с помощью побитового ИЛИ; например, `re.I | re.M` устанавливает оба флага `I` и `M`.294295Ниже приведена таблица доступных флагов, а затем более подробное описание каждого из них.296297| Флаг | Значение |298| --- | --- |299| `ASCII`, `A` | Заставляет несколько управляющих последовательностей, таких как `\w`, `\b`, `\s` и `\d`, совпадать только с ASCII-символами с соответствующим свойством. |300| `DOTALL`, `S` | Заставляет `.` совпадать с любым символом, включая символы новой строки. |301| `IGNORECASE`, `I` | Выполняет регистронезависимое сопоставление. |302| `LOCALE`, `L` | Выполняет сопоставление с учётом локали. |303| `MULTILINE`, `M` | Многострочное сопоставление, затрагивающее `^` и `$`. |304| `VERBOSE`, `X` (для ‘extended’). | Включает подробные (verbose) регулярные выражения, которые можно организовать более чисто и понятно. |305306#### `I`307308#### `IGNORECASE`309310Выполняет регистронезависимое сопоставление; классы символов и строковые литералы будут находить соответствия буквам без учёта регистра. Например, `[A-Z]` будет совпадать и со строчными буквами. Полное сопоставление Unicode также работает, если только флаг `ASCII` не отключает соответствие не-ASCII. Когда шаблоны Unicode `[a-z]` или `[A-Z]` используются в сочетании с флагом `IGNORECASE`, они будут совпадать с 52 ASCII-буквами и 4 дополнительными не-ASCII-буквами: ‘İ’ (U+0130, латинская заглавная буква I с точкой сверху), ‘ı’ (U+0131, латинская строчная буква без точки i), ‘ſ’ (U+017F, латинская строчная буква длинная s) и ‘K’ (U+212A, знак Кельвина). `Spam` будет совпадать с `'Spam'`, `'spam'`, `'spAM'` или `'ſpam'` (последнее совпадает только в режиме Unicode). Это приведение к нижнему регистру не учитывает текущую локаль; оно будет учитывать, если также установлен флаг `LOCALE`.311312#### `L`313314#### `LOCALE`315316Делает `\w`, `\W`, `\b`, `\B` и сопоставление без учёта регистра зависимыми от текущей локали вместо базы данных Unicode.317318Локали – это функция библиотеки C, предназначенная для помощи в написании программ, учитывающих языковые различия. Например, если вы обрабатываете закодированный французский текст, вам может понадобиться написать `\w+` для сопоставления слов, но `\w` сопоставляется только с классом символов `[A-Za-z]` в байтовых шаблонах; он не будет сопоставляться с байтами, соответствующими `é` или `ç`. Если ваша система настроена правильно и выбрана французская локаль, некоторые функции C сообщат программе, что байт, соответствующий `é`, также должен считаться буквой. Установка флага `LOCALE` при компиляции регулярного выражения заставит скомпилированный объект использовать эти функции C для `\w`; это медленнее, но также позволяет `\w+` сопоставлять французские слова так, как вы ожидаете. Использование этого флага не рекомендуется в Python 3, поскольку механизм локали очень ненадёжен, одновременно обрабатывает только одну «культуру» и работает только с 8-битными локалями. Сопоставление с использованием Unicode уже включено по умолчанию в Python 3 для строковых (str) шаблонов, и оно способно обрабатывать разные локали/языки.319320#### `M`321322#### `MULTILINE`323324(`^` и `$` пока не объяснены; они будут представлены в разделе [Дополнительные метасимволы](https://python-all.ru/3.7/howto/regex.html#more-metacharacters).)325326Обычно `^` сопоставляется только в начале строки, а `$` – только в конце строки и непосредственно перед символом новой строки (если он есть) в конце строки. Когда указан этот флаг, `^` сопоставляется в начале строки и в начале каждой строки внутри строки, сразу после каждого символа новой строки. Аналогично, метасимвол `$` сопоставляется в конце строки и в конце каждой строки (непосредственно перед каждым символом новой строки).327328#### `S`329330#### `DOTALL`331332Заставляет специальный символ `'.'` сопоставляться с любым символом, включая символ новой строки; без этого флага `'.'` будет сопоставляться с любым символом, *кроме* символа новой строки.333334#### `A`335336#### `ASCII`337338Заставляет `\w`, `\W`, `\b`, `\B`, `\s` и `\S` выполнять сопоставление только с ASCII вместо полного сопоставления с Unicode. Это имеет смысл только для строковых шаблонов и игнорируется для байтовых шаблонов.339340#### `X`341342#### `VERBOSE`343344Этот флаг позволяет писать более читаемые регулярные выражения, предоставляя больше гибкости в их форматировании. Когда этот флаг указан, пробельные символы внутри строки регулярного выражения игнорируются, за исключением случаев, когда пробел находится внутри символьного класса или перед ним стоит неэкранированная обратная косая черта; это позволяет более четко организовывать и расставлять отступы в регулярном выражении. Этот флаг также позволяет помещать комментарии внутри регулярного выражения, которые будут игнорироваться движком; комментарии обозначаются символом `'#'`, который не находится внутри символьного класса и не предваряется неэкранированной обратной косой чертой.345346Например, вот RE, использующий [`re.VERBOSE`](https://python-all.ru/3.7/library/re.html#re.VERBOSE); посмотрите, насколько его легче читать.347348```python349charref = re.compile(r"""350 &[#]                # Start of a numeric entity reference351 (352     0[0-7]+         # Octal form353   | [0-9]+          # Decimal form354   | x[0-9a-fA-F]+   # Hexadecimal form355 )356 ;                   # Trailing semicolon357""", re.VERBOSE)358```359360Без режима verbose регулярное выражение выглядело бы так:361362```python363charref = re.compile("&#(0[0-7]+"364                     "|[0-9]+"365                     "|x[0-9a-fA-F]+);")366```367368В примере выше автоматическая конкатенация строковых литералов Python использовалась, чтобы разбить RE на более мелкие части, но он всё равно сложнее для понимания, чем версия с [`re.VERBOSE`](https://python-all.ru/3.7/library/re.html#re.VERBOSE).369370## Дополнительные возможности шаблонов371372До сих пор мы рассмотрели только часть возможностей регулярных выражений. В этом разделе мы рассмотрим некоторые новые метасимволы и способы использования групп для извлечения частей сопоставленного текста.373374### Дополнительные метасимволы375376Остались некоторые метасимволы, которые мы ещё не рассмотрели. Большинство из них будет рассмотрено в этом разделе.377378Некоторые из оставшихся метасимволов – это *утверждения нулевой длины*. Они не заставляют движок продвигаться по строке; вместо этого они вообще не потребляют символов и просто возвращают успех или неудачу. Например, `\b` – это утверждение, что текущая позиция находится на границе слова; позиция при этом не меняется `\b` вообще. Это означает, что утверждения нулевой длины не следует повторять, потому что если они совпадают один раз в данной позиции, то они, очевидно, могут совпадать бесконечное число раз.379380**`|`**381382Альтернация, или оператор «или». Если *A* и *B* – регулярные выражения, то `A|B` совпадёт с любой строкой, которая соответствует либо *A*, либо *B*. У `|` очень низкий приоритет, чтобы он работал разумно при альтернации строк из нескольких символов. `Crow|Servo` совпадёт либо с `'Crow'`, либо с `'Servo'`, а не с `'Cro'`, `'w'` или `'S'`, и `'ervo'`.383384Чтобы сопоставить литерал `'|'`, используйте `\|` или заключите его в символьный класс, как в `[|]`.385386**`^`**387388Совпадение в начале строк. Если не установлен флаг `MULTILINE`, соответствует только в начале строки. В режиме `MULTILINE` также совпадает сразу после каждого перевода строки внутри строки.389390Например, если требуется найти слово `From` только в начале строки, нужно использовать RE `^From`.391392```python393>>> print(re.search('^From', 'From Here to Eternity'))  394<re.Match object; span=(0, 4), match='From'>395>>> print(re.search('^From', 'Reciting From Memory'))396None397```398399Чтобы сопоставить литерал `'^'`, используйте `\^`.400401**`$`**402403Совпадение в конце строки, которая определяется как конец строки или любая позиция, за которой следует символ перевода строки.404405```python406>>> print(re.search('}$', '{block}'))  407<re.Match object; span=(6, 7), match='}'>408>>> print(re.search('}$', '{block} '))409None410>>> print(re.search('}$', '{block}\n'))  411<re.Match object; span=(6, 7), match='}'>412```413414Чтобы сопоставить литерал `'$'`, используйте `\$` или заключите его в символьный класс, как в `[$]`.415416**`\A`**417418Совпадение только в начале строки. Вне режима `MULTILINE` `\A` и `^` фактически одинаковы. В режиме `MULTILINE` они различаются: `\A` по-прежнему совпадает только в начале строки, а `^` может совпадать в любом месте строки после символа перевода строки.419420**`\Z`**421422Совпадение только в конце строки.423424**`\b`**425426Граница слова. Это утверждение нулевой длины, которое совпадает только в начале или конце слова. Слово определяется как последовательность буквенно-цифровых символов, поэтому конец слова обозначается пробелом или не-буквенно-цифровым символом.427428Следующий пример находит `class` только когда это целое слово; он не совпадёт, если оно содержится внутри другого слова.429430```python431>>> p = re.compile(r'\bclass\b')432>>> print(p.search('no class at all'))433<re.Match object; span=(3, 8), match='class'>434>>> print(p.search('the declassified algorithm'))435None436>>> print(p.search('one subclass is'))437None438```439440Есть две тонкости, которые следует помнить при использовании этой специальной последовательности. Во-первых, это худшее столкновение между строковыми литералами Python и последовательностями регулярных выражений. В строковых литералах Python `\b` – это символ backspace, ASCII-код 8. Если не используются сырые строки, Python преобразует `\b` в backspace, и RE не будет совпадать так, как ожидается. Следующий пример выглядит так же, как предыдущий RE, но в нём опущен `'r'` перед строкой RE.441442```python443>>> p = re.compile('\bclass\b')444>>> print(p.search('no class at all'))445None446>>> print(p.search('\b' + 'class' + '\b'))447<re.Match object; span=(0, 7), match='\x08class\x08'>448```449450Во-вторых, внутри символьного класса, где это утверждение не используется, `\b` представляет символ backspace для совместимости со строковыми литералами Python.451452**`\B`**453454Ещё одно утверждение нулевой длины, противоположное `\b`, совпадает только когда текущая позиция не находится на границе слова.455456### Группировка457458Часто требуется получить больше информации, чем просто – совпало RE или нет. Регулярные выражения часто используются для разбора строк с помощью RE, разделённого на несколько подгрупп, каждая из которых соответствует интересующему компоненту. Например, строка заголовка RFC-822 разделена на имя заголовка и значение, разделённые `':'`, так:459460```text461From: author@example.com462User-Agent: Thunderbird 1.5.0.9 (X11/20061227)463MIME-Version: 1.0464To: editor@example.com465```466467Это можно обработать, написав регулярное выражение, которое сопоставляет всю строку заголовка, и имеет одну группу для имени заголовка и другую – для значения заголовка.468469Группы обозначаются метасимволами `'('`, `')'`. `'('` и `')'` имеют примерно тот же смысл, что и в математических выражениях: они группируют содержащиеся в них выражения, и содержимое группы можно повторять с помощью повторяющегося квантификатора, например `*`, `+`, `?` или `{m,n}`. Например, `(ab)*` будет соответствовать нулю или более повторениям `ab`.470471```python472>>> p = re.compile('(ab)*')473>>> print(p.match('ababababab').span())474(0, 10)475```476477Группы, обозначенные `'('`, `')'`, также захватывают начальный и конечный индексы сопоставленного текста; их можно получить, передав аргумент методам [`group()`](https://python-all.ru/3.7/library/re.html#re.Match.group), [`start()`](https://python-all.ru/3.7/library/re.html#re.Match.start), [`end()`](https://python-all.ru/3.7/library/re.html#re.Match.end) и [`span()`](https://python-all.ru/3.7/library/re.html#re.Match.span). Группы нумеруются начиная с 0. Группа 0 присутствует всегда; это всё RE, поэтому методы [объекта match](https://python-all.ru/3.7/library/re.html#match-objects) по умолчанию используют группу 0. Позже мы увидим, как задавать группы, которые не захватывают диапазон сопоставленного текста.478479```python480>>> p = re.compile('(a)b')481>>> m = p.match('ab')482>>> m.group()483'ab'484>>> m.group(0)485'ab'486```487488Подгруппы нумеруются слева направо, начиная с 1. Группы могут быть вложенными; чтобы определить номер, нужно просто посчитать открывающие скобки, идя слева направо.489490```python491>>> p = re.compile('(a(b)c)d')492>>> m = p.match('abcd')493>>> m.group(0)494'abcd'495>>> m.group(1)496'abc'497>>> m.group(2)498'b'499```500501[`group()`](https://python-all.ru/3.7/library/re.html#re.Match.group) можно передать несколько номеров групп одновременно, и в этом случае она вернёт кортеж, содержащий соответствующие значения для этих групп.502503```python504>>> m.group(2,1,2)505('b', 'abc', 'b')506```507508Метод [`groups()`](https://python-all.ru/3.7/library/re.html#re.Match.groups) возвращает кортеж, содержащий строки всех подгрупп, от 1 до их количества.509510```python511>>> m.groups()512('abc', 'b')513```514515Обратные ссылки в шаблоне позволяют указать, что содержимое ранее захваченной группы должно также присутствовать в текущей позиции строки. Например, `\1` будет успешным, если точное содержимое группы 1 можно найти в текущей позиции, иначе – нет. Помните, что строковые литералы Python также используют обратную косую черту с числами для включения произвольных символов в строку, поэтому обязательно используйте сырую строку при включении обратных ссылок в RE.516517Например, следующее RE обнаруживает удвоенные слова в строке.518519```python520>>> p = re.compile(r'\b(\w+)\s+\1\b')521>>> p.search('Paris in the the spring').group()522'the the'523```524525Обратные ссылки такого рода редко бывают полезны при простом поиске в строке – существует мало текстовых форматов, которые повторяют данные таким образом, – но вскоре обнаруживается, что они *очень* полезны при выполнении строковых подстановок.526527### Незахватывающие и именованные группы528529Сложные регулярные выражения могут использовать много групп как для захвата интересующих подстрок, так и для группировки и структурирования самого выражения. В сложных RE становится трудно отслеживать номера групп. Существуют две возможности, которые помогают решить эту проблему. Обе используют общий синтаксис расширений регулярных выражений, поэтому сначала рассмотрим его.530531Perl 5 хорошо известен своими мощными дополнениями к стандартным регулярным выражениям. Для этих новых возможностей разработчики Perl не могли выбрать новые метасимволы из одного символа или новые специальные последовательности, начинающиеся с `\`, не сделав регулярные выражения Perl запутанно отличающимися от стандартных RE. Если бы они выбрали `&` в качестве нового метасимвола, например, старые выражения предполагали бы, что `&` – это обычный символ, и не экранировали бы его, записывая `\&` или `[&]`.532533Разработчики Perl выбрали `(?...)` в качестве синтаксиса расширения. `?` сразу после круглой скобки был синтаксической ошибкой, потому что `?` нечего было бы повторять, так что это не вызвало проблем совместимости. Символы сразу после `?` указывают, какое расширение используется, так что `(?=foo)` – это одно (положительная опережающая проверка), а `(?:foo)` – другое (незахватывающая группа, содержащая подвыражение `foo`).534535Python поддерживает несколько расширений Perl и добавляет собственный синтаксис расширений к синтаксису расширений Perl. Если первый символ после вопросительного знака – `P`, то это расширение, специфичное для Python.536537Теперь, когда мы рассмотрели общий синтаксис расширений, можно вернуться к возможностям, упрощающим работу с группами в сложных RE.538539Иногда требуется использовать группу для обозначения части регулярного выражения, но нет необходимости извлекать содержимое группы. Это можно явно указать с помощью незахватывающей группы: `(?:...)`, где `...` можно заменить любым другим регулярным выражением.540541```python542>>> m = re.match("([abc])+", "abc")543>>> m.groups()544('c',)545>>> m = re.match("(?:[abc])+", "abc")546>>> m.groups()547()548```549550За исключением того, что нельзя извлечь содержимое того, что сопоставила группа, незахватывающая группа ведёт себя точно так же, как захватывающая: в неё можно поместить что угодно, повторить её с помощью метасимвола повторения, такого как `*`, и вложить в другие группы (захватывающие или незахватывающие). `(?:...)` особенно полезен при изменении существующего шаблона, поскольку можно добавлять новые группы, не меняя нумерацию всех остальных групп. Стоит упомянуть, что нет разницы в производительности поиска между захватывающими и незахватывающими группами; ни одна из форм не быстрее другой.551552Более значимая возможность – именованные группы: вместо обращения по номерам группы можно ссылаться по имени.553554Синтаксис именованной группы – одно из расширений, специфичных для Python: `(?P<name>...)`. *name* – это, очевидно, имя группы. Именованные группы ведут себя точно так же, как захватывающие, и дополнительно связывают имя с группой. Методы [объекта match](https://python-all.ru/3.7/library/re.html#match-objects), которые работают с захватывающими группами, принимают как целые числа, обозначающие группу по номеру, так и строки, содержащие имя нужной группы. Именованные группы по-прежнему имеют номера, поэтому информацию о группе можно получить двумя способами:555556```python557>>> p = re.compile(r'(?P<word>\b\w+\b)')558>>> m = p.search( '(((( Lots of punctuation )))' )559>>> m.group('word')560'Lots'561>>> m.group(1)562'Lots'563```564565Именованные группы удобны, поскольку позволяют использовать легко запоминающиеся имена вместо запоминания номеров. Вот пример RE из модуля [`imaplib`](https://python-all.ru/3.7/library/imaplib.html#module-imaplib):566567```python568InternalDate = re.compile(r'INTERNALDATE "'569        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'570        r'(?P<year>[0-9][0-9][0-9][0-9])'571        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'572        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'573        r'"')574```575576Очевидно, что гораздо проще получить `m.group('zonem')`, чем запоминать, что нужно получить группу 9.577578Синтаксис обратных ссылок в выражении, таком как `(...)\1`, относится к номеру группы. Естественно, существует вариант, использующий имя группы вместо номера. Это ещё одно расширение Python: `(?P=name)` указывает, что содержимое группы с именем *name* должно снова совпадать в текущей позиции. Регулярное выражение для поиска удвоенных слов, `\b(\w+)\s+\1\b`, можно также записать как `\b(?P<word>\w+)\s+(?P=word)\b`:579580```python581>>> p = re.compile(r'\b(?P<word>\w+)\s+(?P=word)\b')582>>> p.search('Paris in the the spring').group()583'the the'584```585586### Опережающие проверки587588Ещё одна проверка нулевой ширины – опережающая проверка. Опережающие проверки бывают положительными и отрицательными и выглядят так:589590**`(?=...)`**591592Положительная опережающая проверка. Она успешна, если вложенное регулярное выражение, представленное здесь как `...`, успешно совпадает в текущей позиции, и неуспешна в противном случае. Но как только вложенное выражение проверено, движок сопоставления не продвигается; остальная часть шаблона проверяется прямо с того места, где началась проверка.593594**`(?!...)`**595596Отрицательная опережающая проверка. Это противоположность положительной проверке; она успешна, если вложенное выражение *не* совпадает в текущей позиции строки.597598Чтобы сделать это конкретным, рассмотрим случай, где опережающая проверка полезна. Рассмотрим простой шаблон для сопоставления имени файла и разделения его на базовое имя и расширение, разделённых точкой `.`. Например, в `news.rc` `news` – это базовое имя, а `rc` – расширение файла.599600Шаблон для сопоставления этого довольно прост:601602`.*[.].*$`603604Обратите внимание, что `.` нужно обрабатывать особым образом, потому что это метасимвол, поэтому он помещён в символьный класс, чтобы сопоставлять только этот конкретный символ. Также обратите внимание на завершающий `$`; он добавлен, чтобы гарантировать, что вся оставшаяся часть строки входит в расширение. Это регулярное выражение сопоставляется с `foo.bar`, `autoexec.bat`, `sendmail.cf` и `printers.conf`.605606Теперь усложним задачу: что, если нужно сопоставить имена файлов, расширение которых не равно `bat`? Некоторые неверные попытки:607608`.*[.][^b].*$` Первая попытка выше пытается исключить `bat`, требуя, чтобы первый символ расширения не был `b`. Это неправильно, потому что шаблон также не соответствует `foo.bar`.609610`.*[.]([^b]..|.[^a].|..[^t])$`611612Выражение становится более запутанным, если попытаться исправить первое решение, потребовав совпадения одного из следующих случаев: первый символ расширения не `b`; второй символ не `a`; или третий символ не `t`. Это принимает `foo.bar` и отвергает `autoexec.bat`, но требует трёхбуквенного расширения и не принимает имя файла с двухбуквенным расширением, например `sendmail.cf`. Мы снова усложним шаблон, пытаясь это исправить.613614`.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$`615616В третьей попытке вторая и третья буквы сделаны необязательными, чтобы разрешить сопоставление расширений короче трёх символов, например `sendmail.cf`.617618Шаблон становится очень сложным, что затрудняет его чтение и понимание. Хуже того, если задача изменится и потребуется исключить как `bat`, так и `exe` в качестве расширений, шаблон станет ещё более запутанным и сложным.619620Отрицательная опережающая проверка разрешает всю эту путаницу:621622`.*[.](?!bat$)[^.]*$` Отрицательная опережающая проверка означает: если выражение `bat` не совпадает в этой точке, попробуйте оставшуюся часть шаблона; если `bat$` совпадает, весь шаблон не сработает. Замыкающий `$` требуется, чтобы гарантировать, что нечто вроде `sample.batch`, где расширение начинается только с `bat`, будет разрешено. `[^.]*` гарантирует, что шаблон работает, когда в имени файла есть несколько точек.623624Исключить другое расширение файла теперь легко: просто добавьте его как альтернативу внутри проверки. Следующий шаблон исключает имена файлов, которые заканчиваются на `bat` или `exe`:625626`.*[.](?!bat$|exe$)[^.]*$`627628## Изменение строк629630До этого момента мы просто выполняли поиск в статической строке. Регулярные выражения также часто используются для изменения строк различными способами с помощью следующих методов шаблона:631632| Метод/Атрибут | Назначение |633| --- | --- |634| `split()` | Разделяет строку на список, разбивая её везде, где совпадает RE |635| `sub()` | Находит все подстроки, совпадающие с RE, и заменяет их на другую строку |636| `subn()` | Делает то же самое, что `sub()`, но возвращает новую строку и количество замен |637638### Разделение строк639640Метод [`split()`](https://python-all.ru/3.7/library/re.html#re.Pattern.split) шаблона разделяет строку везде, где совпадает RE, возвращая список частей. Он похож на метод [`split()`](https://python-all.ru/3.7/library/stdtypes.html#str.split) строк, но предоставляет гораздо большую гибкость в разделителях, по которым можно разбивать; строковый `split()` поддерживает разбиение только по пробельным символам или по фиксированной строке. Как и следовало ожидать, существует также функция уровня модуля [`re.split()`](https://python-all.ru/3.7/library/re.html#re.split).641642#### `.split(string[, maxsplit=0])`643644Разделяет *строку* по совпадениям регулярного выражения. Если в RE используются захватывающие круглые скобки, то их содержимое также будет возвращено как часть результирующего списка. Если *maxsplit* не равно нулю, выполняется не более *maxsplit* разбиений.645646Количество выполняемых разбиений можно ограничить, передав значение для *maxsplit*. Если *maxsplit* не равно нулю, будет выполнено не более *maxsplit* разбиений, а остаток строки возвращается как последний элемент списка. В следующем примере разделителем является любая последовательность неалфавитно-цифровых символов.647648```python649>>> p = re.compile(r'\W+')650>>> p.split('This is a test, short and sweet, of split().')651['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']652>>> p.split('This is a test, short and sweet, of split().', 3)653['This', 'is', 'a', 'test, short and sweet, of split().']654```655656Иногда нужно знать не только текст между разделителями, но и сам разделитель. Если в RE используются захватывающие круглые скобки, то их значения также возвращаются как часть списка. Сравните следующие вызовы:657658```python659>>> p = re.compile(r'\W+')660>>> p2 = re.compile(r'(\W+)')661>>> p.split('This... is a test.')662['This', 'is', 'a', 'test', '']663>>> p2.split('This... is a test.')664['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']665```666667Функция уровня модуля [`re.split()`](https://python-all.ru/3.7/library/re.html#re.split) добавляет RE, используемый как первый аргумент, но в остальном идентична.668669```python670>>> re.split(r'[\W]+', 'Words, words, words.')671['Words', 'words', 'words', '']672>>> re.split(r'([\W]+)', 'Words, words, words.')673['Words', ', ', 'words', ', ', 'words', '.', '']674>>> re.split(r'[\W]+', 'Words, words, words.', 1)675['Words', 'words, words.']676```677678### Поиск и замена679680Ещё одна распространённая задача – найти все совпадения с шаблоном и заменить их другой строкой. Метод [`sub()`](https://python-all.ru/3.7/library/re.html#re.Pattern.sub) принимает значение замены, которое может быть строкой или функцией, и обрабатываемую строку.681682#### `.sub(replacement, string[, count=0])`683684Возвращает строку, полученную заменой самых левых непересекающихся совпадений RE в *строке* на замену *replacement*. Если шаблон не найден, *строка* возвращается без изменений.685686Необязательный аргумент *count* – максимальное количество заменяемых вхождений шаблона; *count* должно быть неотрицательным целым числом. Значение по умолчанию 0 означает замену всех вхождений.687688Вот простой пример использования метода [`sub()`](https://python-all.ru/3.7/library/re.html#re.Pattern.sub). Он заменяет названия цветов словом `colour`:689690```python691>>> p = re.compile('(blue|white|red)')692>>> p.sub('colour', 'blue socks and red shoes')693'colour socks and colour shoes'694>>> p.sub('colour', 'blue socks and red shoes', count=1)695'colour socks and red shoes'696```697698Метод [`subn()`](https://python-all.ru/3.7/library/re.html#re.Pattern.subn) делает то же самое, но возвращает кортеж из двух элементов, содержащий новую строку и количество выполненных замен:699700```python701>>> p = re.compile('(blue|white|red)')702>>> p.subn('colour', 'blue socks and red shoes')703('colour socks and colour shoes', 2)704>>> p.subn('colour', 'no colours at all')705('no colours at all', 0)706```707708Пустые совпадения заменяются только тогда, когда они не примыкают к предыдущему пустому совпадению.709710```python711>>> p = re.compile('x*')712>>> p.sub('-', 'abxd')713'-a-b--d-'714```715716Если *replacement* является строкой, все escape-последовательности с обратной косой чертой обрабатываются. То есть `\n` преобразуется в символ новой строки, `\r` – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как `\&`, остаются без изменений. Обратные ссылки, например `\6`, заменяются подстрокой, совпавшей с соответствующей группой в регулярном выражении. Это позволяет включать части исходного текста в результирующую строку замены.717718В этом примере ищется слово `section`, за которым следует строка, заключённая в `{`, `}`, и `section` заменяется на `subsection`:719720```python721>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)722>>> p.sub(r'subsection{\1}','section{First} section{second}')723'subsection{First} subsection{second}'724```725726Существует также синтаксис для ссылки на именованные группы, определённые с помощью синтаксиса `(?P<name>...)`. `\g<name>` будет использовать подстроку, совпавшую с группой с именем `name`, а `\g<number>` использует соответствующий номер группы. Таким образом, `\g<2>` эквивалентно `\2`, но не является неоднозначным в строке замены, такой как `\g<2>0`. (`\20` было бы интерпретировано как ссылка на группу 20, а не как ссылка на группу 2, за которой следует литеральный символ `'0'`.) Следующие подстановки эквивалентны, но используют все три варианта строки замены.727728```python729>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)730>>> p.sub(r'subsection{\1}','section{First}')731'subsection{First}'732>>> p.sub(r'subsection{\g<1>}','section{First}')733'subsection{First}'734>>> p.sub(r'subsection{\g<name>}','section{First}')735'subsection{First}'736```737738*replacement* также может быть функцией, что даёт ещё больше контроля. Если *replacement* является функцией, она вызывается для каждого непересекающегося вхождения *pattern*. При каждом вызове функции передаётся аргумент [объект совпадения](https://python-all.ru/3.7/library/re.html#match-objects) и она может использовать эту информацию для вычисления нужной строки замены и возврата её.739740В следующем примере функция замены преобразует десятичные числа в шестнадцатеричные:741742```python743>>> def hexrepl(match):744...     "Return the hex string for a decimal number"745...     value = int(match.group())746...     return hex(value)747...748>>> p = re.compile(r'\d+')749>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')750'Call 0xffd2 for printing, 0xc000 for user code.'751```752753При использовании функции уровня модуля [`re.sub()`](https://python-all.ru/3.7/library/re.html#re.sub) шаблон передаётся как первый аргумент. Шаблон может быть предоставлен как объект или как строка; если нужно указать флаги регулярного выражения, необходимо либо использовать объект шаблона в качестве первого параметра, либо использовать встроенные модификаторы в строке шаблона, например `sub("(?i)b+", "x", "bbbb BBBB")` возвращает `'x x'`.754755## Распространенные проблемы756757Регулярные выражения – мощный инструмент для некоторых приложений, но в некоторых аспектах их поведение не интуитивно и иногда они ведут себя не так, как можно было бы ожидать. В этом разделе будут указаны некоторые наиболее распространённые ошибки.758759### Применение строковых методов760761Иногда использование модуля [`re`](https://python-all.ru/3.7/library/re.html#module-re) является ошибкой. Если производится сопоставление с фиксированной строкой или одиночным классом символов и не используются никакие возможности [`re`](https://python-all.ru/3.7/library/re.html#module-re), такие как флаг [`IGNORECASE`](https://python-all.ru/3.7/library/re.html#re.IGNORECASE), то вся мощь регулярных выражений может не понадобиться. Строки имеют несколько методов для выполнения операций с фиксированными строками, и они обычно намного быстрее, поскольку реализация представляет собой один небольшой цикл на C, оптимизированный для этой цели, а не большой, более обобщённый движок регулярных выражений.762763Примером может быть замена одной фиксированной строки на другую; например, можно заменить `word` на `deed`. [`re.sub()`](https://python-all.ru/3.7/library/re.html#re.sub) кажется подходящей функцией для этого, но рассмотрите метод [`replace()`](https://python-all.ru/3.7/library/stdtypes.html#str.replace). Обратите внимание, что `replace()` также заменит `word` внутри слов, превратив `swordfish` в `sdeedfish`, но наивное RE `word` сделало бы то же самое. (Чтобы избежать замены в частях слов, шаблон должен быть `\bword\b`, чтобы требовать, чтобы `word` имело границу слова с обеих сторон. Это выходит за рамки возможностей `replace()`.)764765Ещё одна распространённая задача – удаление всех вхождений одного символа из строки или замена его другим символом. Можно сделать это с помощью чего-то вроде `re.sub('\n', ' ', S)`, но [`translate()`](https://python-all.ru/3.7/library/stdtypes.html#str.translate) способен выполнить обе задачи и будет быстрее любой операции с регулярными выражениями.766767Короче говоря, прежде чем обращаться к модулю [`re`](https://python-all.ru/3.7/library/re.html#module-re), подумайте, не решается ли ваша задача более быстрым и простым строковым методом.768769### match() и search()770771Функция [`match()`](https://python-all.ru/3.7/library/re.html#re.match) проверяет совпадение только в начале строки, тогда как [`search()`](https://python-all.ru/3.7/library/re.html#re.search) просматривает строку в поисках совпадения. Важно помнить об этом различии. Помните: `match()` сообщит об успешном совпадении, только если оно начинается с 0; если совпадение начинается не с нуля, `match()` *не* сообщит о нём.772773```python774>>> print(re.match('super', 'superstition').span())775(0, 5)776>>> print(re.match('super', 'insuperable'))777None778```779780С другой стороны, [`search()`](https://python-all.ru/3.7/library/re.html#re.search) будет просматривать строку и сообщать о первом найденном совпадении.781782```python783>>> print(re.search('super', 'superstition').span())784(0, 5)785>>> print(re.search('super', 'insuperable').span())786(2, 7)787```788789Иногда возникает соблазн продолжать использовать [`re.match()`](https://python-all.ru/3.7/library/re.html#re.match) и просто добавлять `.*` в начало RE. Сопротивляйтесь этому соблазну и используйте [`re.search()`](https://python-all.ru/3.7/library/re.html#re.search). Компилятор регулярных выражений выполняет некоторый анализ RE, чтобы ускорить процесс поиска совпадения. Один из таких анализов определяет, каким должен быть первый символ совпадения; например, шаблон, начинающийся с `Crow`, должен совпадать с `'C'`. Анализ позволяет движку быстро просматривать строку в поисках начального символа, пробуя полное совпадение только если найден `'C'`.790791Добавление `.*` сводит на нет эту оптимизацию, требуя сканирования до конца строки и последующего возврата для поиска совпадения для остальной части RE. Используйте [`re.search()`](https://python-all.ru/3.7/library/re.html#re.search) вместо этого.792793### Жадный и нежадный режимы794795При повторении регулярного выражения, как в `a*`, результатом является потребление как можно большей части шаблона. Этот факт часто подводит, когда пытаются сопоставить пару сбалансированных разделителей, например, угловые скобки, окружающие HTML-тег. Наивный шаблон для сопоставления одного HTML-тега не работает из-за жадной природы `.*`.796797```python798>>> s = '<html><head><title>Title</title>'799>>> len(s)80032801>>> print(re.match('<.*>', s).span())802(0, 32)803>>> print(re.match('<.*>', s).group())804<html><head><title>Title</title>805```806807RE находит `'<'` в `'<html>'`, а `.*` поглощает остаток строки. Однако в RE остаётся ещё часть, и `>` не может совпасть в конце строки, поэтому движку регулярных выражений приходится возвращаться посимвольно, пока он не найдёт совпадение для `>`. Итоговое совпадение простирается от `'<'` в `'<html>'` до `'>'` в `'</title>'`, что не то, что нужно.808809В этом случае решение – использовать нежадные квантификаторы `*?`, `+?`, `??` или `{m,n}?`, которые захватывают как *мало* текста, насколько это возможно. В приведённом выше примере `'>'` проверяется сразу после совпадения первого `'<'`, и когда это не удаётся, движок продвигается на один символ, заново проверяя `'>'` на каждом шаге. Это даёт правильный результат:810811```python812>>> print(re.match('<.*?>', s).group())813<html>814```815816(Заметьте, что разбор HTML или XML с помощью регулярных выражений – дело мучительное. Быстрые и грязные шаблоны справятся с обычными случаями, но у HTML и XML есть особые случаи, которые сломают очевидное регулярное выражение; к тому времени, как вы напишете регулярное выражение, обрабатывающее все возможные случаи, шаблоны станут *очень* сложными. Используйте для таких задач модуль разбора HTML или XML.)817818### Использование re.VERBOSE819820К этому моменту вы, вероятно, заметили, что регулярные выражения – это очень компактная запись, но они не слишком читаемы. RE умеренной сложности могут превратиться в длинные наборы обратных слешей, скобок и метасимволов, что затрудняет их чтение и понимание.821822Для таких RE указание флага [`re.VERBOSE`](https://python-all.ru/3.7/library/re.html#re.VERBOSE) при компиляции регулярного выражения может быть полезно, поскольку позволяет форматировать регулярное выражение более чётко.823824Флаг `re.VERBOSE` имеет несколько эффектов. Пробельные символы в регулярном выражении, которые *не находятся* внутри символьного класса, игнорируются. Это означает, что выражение вида `dog | cat` эквивалентно менее читаемому `dog|cat`, но `[a b]` по-прежнему будет соответствовать символам `'a'`, `'b'` или пробелу. Кроме того, в RE можно вставлять комментарии; комментарии начинаются с символа `#` и продолжаются до следующей новой строки. При использовании с тройными кавычками это позволяет форматировать RE более аккуратно:825826```python827pat = re.compile(r"""828 \s*                 # Skip leading whitespace829 (?P<header>[^:]+)   # Header name830 \s* :               # Whitespace, and a colon831 (?P<value>.*?)      # The header's value -- *? used to832                     # lose the following trailing whitespace833 \s*$                # Trailing whitespace to end-of-line834""", re.VERBOSE)835```836837Это гораздо читаемее, чем:838839```python840pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")841```842843## Обратная связь844845Регулярные выражения – сложная тема. Помог ли вам этот документ понять их? Были ли части, которые остались неясными, или проблемы, с которыми вы столкнулись и которые не были здесь рассмотрены? Если да, отправьте предложения по улучшению автору.846847Наиболее полной книгой по регулярным выражениям, пожалуй, является \*Mastering Regular Expressions\* Джеффри Фридла, издательство O’Reilly. К сожалению, она сосредоточена исключительно на разновидностях регулярных выражений Perl и Java и вообще не содержит материала по Python, так что она не пригодится в качестве справочника по программированию на Python. (В первом издании рассматривался модуль `regex`, который теперь удалён из Python, что вам не сильно поможет.) Рекомендуем взять её в библиотеке.848