`regex.md`

862 строк · 94.6 КБ · обычная страница · сырой текст · скачать
1> **Источник:** https://python-all.ru/3.15/howto/regex.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# HOWTO по регулярным выражениям89Аннотация1011Этот документ – вводное руководство по использованию регулярных выражений в Python с модулем [`re`](https://python-all.ru/3.15/library/re.html#module-re). Оно даёт более плавное введение, чем соответствующий раздел в справочнике по библиотеке.1213## Введение1415Регулярные выражения (называемые RE, или regex, или regex-шаблоны) – это, по сути, крошечный, узкоспециализированный язык программирования, встроенный в Python и доступный через модуль [`re`](https://python-all.ru/3.15/library/re.html#module-re). С помощью этого небольшого языка вы задаёте правила для множества возможных строк, которые хотите сопоставить; это множество может содержать английские предложения, адреса электронной почты, команды TeX или что угодно. Затем можно задавать вопросы вроде «Соответствует ли эта строка шаблону?» или «Есть ли совпадение с шаблоном где-либо в этой строке?». С помощью RE можно также изменять строку или разделять её различными способами.1617Шаблоны регулярных выражений компилируются в набор байткодов, которые затем выполняются механизмом сопоставления, написанным на C. Для продвинутого использования может потребоваться тщательно следить за тем, как механизм будет выполнять данное RE, и писать RE определённым образом, чтобы получить байткод, работающий быстрее. Оптимизация не рассматривается в этом документе, поскольку она требует хорошего понимания внутреннего устройства механизма сопоставления.1819Язык регулярных выражений относительно мал и ограничен, поэтому не все задачи обработки строк можно решить с помощью регулярных выражений. Существуют также задачи, которые *можно* выполнить с помощью регулярных выражений, но выражения оказываются очень сложными. В таких случаях, возможно, лучше написать код на Python для обработки; хотя код на Python будет медленнее, чем сложное регулярное выражение, он, вероятно, будет более понятным.2021## Простые шаблоны2223Начнём с изучения самых простых регулярных выражений. Поскольку регулярные выражения используются для работы со строками, начнём с самой распространённой задачи: сопоставления символов.2425Подробное объяснение теоретических основ регулярных выражений (детерминированные и недетерминированные конечные автоматы) можно найти почти в любом учебнике по написанию компиляторов.2627### Сопоставление символов2829Большинство букв и символов сопоставляются сами с собой. Например, регулярное выражение `test` будет точно соответствовать строке `test`. (Можно включить регистронезависимый режим, который позволит этому РВ сопоставляться также с `Test` или `TEST`; подробнее об этом позже.)3031Из этого правила есть исключения: некоторые символы являются специальными *метасимволами* и не сопоставляются сами с собой. Вместо этого они указывают, что должно быть сопоставлено что-то необычное, или влияют на другие части РВ, повторяя их или меняя их значение. Значительная часть этого документа посвящена обсуждению различных метасимволов и их действий.3233Вот полный список метасимволов; их значения будут рассмотрены в остальной части этого HOWTO.3435```text36. ^ $ * + ? { } [ ] \ | ( )37```3839Первые метасимволы, которые мы рассмотрим, – это `[` и `]`. Они используются для определения символьного класса – набора символов, которые нужно сопоставить. Символы можно перечислить по отдельности, или указать диапазон символов, задав два символа и разделив их дефисом `'-'`. Например, `[abc]` будет соответствовать любому из символов `a`, `b` или `c`; это то же самое, что `[a-c]`, где диапазон выражает тот же набор символов. Если нужно сопоставлять только строчные буквы, РВ будет `[a-z]`.4041Метасимволы (кроме `\`) внутри классов неактивны. Например, `[akm$]` будет соответствовать любому из символов `'a'`, `'k'`, `'m'` или `'$'`; `'$'` обычно является метасимволом, но внутри символьного класса он лишается своего специального значения.4243Можно сопоставлять символы, не входящие в класс, *дополняя* набор. Это обозначается включением `'^'` в качестве первого символа класса. Например, `[^5]` будет соответствовать любому символу, кроме `'5'`. Если символ крышки (^) появляется в другом месте символьного класса, он не имеет специального значения. Например: `[5^]` будет соответствовать либо `'5'`, либо `'^'`.4445Пожалуй, самый важный метасимвол – обратная косая черта, `\`. Как и в строковых литералах Python, за обратной косой чертой могут следовать различные символы для обозначения специальных последовательностей. Она также используется для экранирования всех метасимволов, чтобы их можно было сопоставлять в шаблонах; например, если нужно сопоставить `[` или `\`, можно поставить перед ними обратную косую черту, чтобы убрать их специальное значение: `\[` или `\\`.4647Некоторые специальные последовательности, начинающиеся с `'\'`, представляют предопределённые наборы символов, которые часто бывают полезны: например, набор цифр, набор букв или набор всего, что не является пробельным символом.4849Рассмотрим пример: `\w` соответствует любому буквенно-цифровому символу. Если шаблон регулярного выражения задан в байтах, это эквивалентно классу `[a-zA-Z0-9_]`. Если шаблон – строка, `\w` будет соответствовать всем символам, помеченным как буквы в базе данных Unicode, которую предоставляет модуль [`unicodedata`](https://python-all.ru/3.15/library/unicodedata.html#module-unicodedata). Можно использовать более ограниченное определение `\w` в строковом шаблоне, указав флаг [`re.ASCII`](https://python-all.ru/3.15/library/re.html#re.ASCII) при компиляции регулярного выражения.5051Следующий список специальных последовательностей неполон. Полный список последовательностей и расширенных определений классов для строковых шаблонов Unicode см. в последней части [Синтаксис регулярных выражений](https://python-all.ru/3.15/library/re.html#re-syntax) в справочнике стандартной библиотеки. В общем, версии Unicode соответствуют любому символу, находящемуся в соответствующей категории в базе данных Unicode.5253**`\d`**5455Соответствует любой десятичной цифре; эквивалентно классу `[0-9]`.5657**`\D`**5859Соответствует любому нецифровому символу; эквивалентно классу `[^0-9]`.6061**`\s`**6263Соответствует любому пробельному символу; эквивалентно классу `[ \t\n\r\f\v]`.6465**`\S`**6667Соответствует любому непробельному символу; эквивалентно классу `[^ \t\n\r\f\v]`.6869**`\w`**7071Соответствует любому буквенно-цифровому символу; эквивалентно классу `[a-zA-Z0-9_]`.7273**`\W`**7475Соответствует любому не буквенно-цифровому символу; эквивалентно классу `[^a-zA-Z0-9_]`.7677Эти последовательности можно включать внутрь символьного класса. Например, `[\s,.]` – это символьный класс, который будет соответствовать любому пробельному символу, или `','`, или `'.'`.7879Последний метасимвол в этом разделе – `.`. Он соответствует любому символу, кроме символа новой строки, и есть альтернативный режим ([`re.DOTALL`](https://python-all.ru/3.15/library/re.html#re.DOTALL)), в котором он будет соответствовать даже новой строке. `.` часто используется, когда нужно сопоставить «любой символ».8081### Повторение8283Возможность сопоставлять различные наборы символов – это первое, что регулярные выражения умеют делать, чего уже нельзя сделать с помощью методов строк. Однако если бы это была единственная дополнительная возможность регулярных выражений, они не были бы большим достижением. Ещё одна возможность – указывать, что части РВ должны повторяться определённое количество раз.8485Первый метасимвол для повторения, который мы рассмотрим, – это `*`. `*` не соответствует литеральному символу `'*'`; вместо этого он указывает, что предыдущий символ может быть сопоставлен ноль или более раз, а не ровно один раз.8687Например, `ca*t` будет соответствовать `'ct'` (0 символов `'a'`), `'cat'` (1 символ `'a'`), `'caaat'` (3 символа `'a'`) и так далее.8889Повторения, такие как `*`, являются *жадными*; при повторении РВ движок сопоставления будет стараться повторить его как можно больше раз. Если более поздние части шаблона не совпадают, движок сопоставления отступает и пробует снова с меньшим числом повторений.9091Пошаговый пример прояснит это. Рассмотрим выражение `a[bcd]*b`. Оно соответствует букве `'a'`, нулю или более букв из класса `[bcd]` и заканчивается символом `'b'`. Теперь представим, что это РВ сопоставляется со строкой `'abcbd'`.9293| Шаг | Совпадение | Пояснение |94| --- | --- | --- |95| 1 | `a` | `a` в РВ совпадает. |96| 2 | `abcbd` | Движок сопоставляет `[bcd]*`, продвигаясь так далеко, как может, то есть до конца строки. |97| 3 | *Неудача* | Движок пытается сопоставить `b`, но текущая позиция находится в конце строки, поэтому попытка не удаётся. |98| 4 | `abcb` | Отступ, чтобы `[bcd]*` сопоставляло на один символ меньше. |99| 5 | *Неудача* | Снова попробовать `b`, но текущая позиция находится на последнем символе, которым является `'d'`. |100| 6 | `abc` | Снова отступ, чтобы `[bcd]*` сопоставляло только `bc`. |101| 7 | `abcb` | Снова попробовать `b`. На этот раз символ в текущей позиции – `'b'`, поэтому совпадение находится. |102103Конец регулярного выражения достигнут, и оно сопоставило `'abcb'`. Это показывает, как движок сопоставления сначала заходит так далеко, как может, а если совпадение не найдено, постепенно отступает и снова и снова перебирает остальную часть регулярного выражения. Он будет отступать до тех пор, пока не попробует ноль совпадений для `[bcd]*`, и если это впоследствии не удастся, движок приходит к выводу, что строка вообще не соответствует регулярному выражению.104105Ещё один повторяющийся метасимвол – `+`, который совпадает один или более раз. Обратите внимание на разницу между `*` и `+`; `*` совпадает *ноль* или более раз, так что повторяемый элемент может отсутствовать вовсе, тогда как `+` требует как минимум *одного* вхождения. Для похожего примера `ca+t` будет совпадать с `'cat'` (1 `'a'`), `'caaat'` (3 `'a'`), но не совпадёт с `'ct'`.106107Существуют ещё два повторяющихся оператора или квантификатора. Символ вопроса `?` совпадает либо один раз, либо ноль; можно считать, что он помечает что-то как необязательное. Например, `home-?brew` совпадает либо с `'homebrew'`, либо с `'home-brew'`.108109Самый сложный квантификатор – `{m,n}`, где *m* и *n* – десятичные целые числа. Этот квантификатор означает, что должно быть как минимум *m* повторений и не более *n*. Например, `a/{1,3}b` совпадёт с `'a/b'`, `'a//b'` и `'a///b'`. Он не совпадёт с `'ab'` (нет косых черт) или с `'a////b'` (их четыре).110111Можно опустить либо *m*, либо *n*; в этом случае для отсутствующего значения используется разумное значение по умолчанию. Пропуск *m* интерпретируется как нижняя граница 0, а пропуск *n* даёт верхнюю границу бесконечность.112113Простейший случай `{m}` совпадает с предыдущим элементом ровно *m* раз. Например, `a/{2}b` совпадёт только с `'a//b'`.114115Читатели, склонные к минимизации, могут заметить, что три других квантификатора можно выразить с помощью этой записи. `{0,}` – то же самое, что `*`, `{1,}` эквивалентно `+`, а `{0,1}` – то же самое, что `?`. Лучше использовать `*`, `+` или `?`, когда это возможно, просто потому что они короче и легче читаются.116117## Использование регулярных выражений118119Теперь, когда мы рассмотрели некоторые простые регулярные выражения, как же их использовать в Python? Модуль [`re`](https://python-all.ru/3.15/library/re.html#module-re) предоставляет интерфейс к движку регулярных выражений, позволяя компилировать регулярные выражения в объекты и затем выполнять с ними сопоставление.120121### Компиляция регулярных выражений122123Регулярные выражения компилируются в объекты шаблонов, которые имеют методы для различных операций, таких как поиск совпадений с шаблоном или выполнение подстановок в строке.124125```python126>>> import re127>>> p = re.compile('ab*')128>>> p129re.compile('ab*')130```131132[`re.compile()`](https://python-all.ru/3.15/library/re.html#re.compile) также принимает необязательный аргумент *flags*, используемый для включения различных специальных возможностей и вариантов синтаксиса. Мы рассмотрим доступные настройки позже, а пока достаточно одного примера:133134```python135>>> p = re.compile('ab*', re.IGNORECASE)136```137138RE передаётся в [`re.compile()`](https://python-all.ru/3.15/library/re.html#re.compile) в виде строки. RE обрабатываются как строки, поскольку регулярные выражения не являются частью ядра языка Python, и для их записи не был создан специальный синтаксис. (Существуют приложения, которым RE вообще не нужны, поэтому нет необходимости раздувать спецификацию языка, включая их.) Вместо этого модуль [`re`](https://python-all.ru/3.15/library/re.html#module-re) – это просто модуль-расширение на C, поставляемый с Python, точно так же, как модули [`socket`](https://python-all.ru/3.15/library/socket.html#module-socket) или [`zlib`](https://python-all.ru/3.15/library/zlib.html#module-zlib).139140Размещение RE в строках сохраняет язык Python более простым, но имеет один недостаток, который является темой следующего раздела.141142### Чума обратных слешей143144Как было сказано ранее, регулярные выражения используют символ обратной косой черты (`'\'`) для обозначения специальных форм или для использования специальных символов без их специального значения. Это конфликтует с использованием того же символа в строковых литералах Python для той же цели.145146Допустим, нужно написать RE, которое бы совпадало со строкой `\section`, которая может встретиться в файле LaTeX. Чтобы понять, что написать в коде программы, начнём с желаемой строки для совпадения. Затем необходимо экранировать все обратные слеши и другие метасимволы, поставив перед ними обратную косую черту, в результате получится строка `\\section`. Итоговая строка, которую нужно передать в [`re.compile()`](https://python-all.ru/3.15/library/re.html#re.compile), должна быть `\\section`. Однако, чтобы представить это в виде строкового литерала Python, оба обратных слеша нужно экранировать *снова*.147148| Символы | Этап |149| --- | --- |150| `\section` | Строка для совпадения |151| `\\section` | Экранированный обратный слеш для [`re.compile()`](https://python-all.ru/3.15/library/re.html#re.compile) |152| `"\\\\section"` | Экранированные обратные слеши для строкового литерала |153154Короче говоря, для сопоставления с литералом обратной косой черты нужно записать `'\\\\'` в качестве строки RE, потому что регулярное выражение должно быть `\\`, а каждый обратный слеш должен быть представлен как `\\` внутри обычного строкового литерала Python. В RE, где обратные слеши встречаются многократно, это приводит к множеству повторных слешей и делает итоговые строки трудными для понимания.155156Решение – использовать сырые строки Python для регулярных выражений; обратные слеши не обрабатываются особым образом в строковом литерале с префиксом `'r'`, поэтому `r"\n"` – это двухсимвольная строка, содержащая `'\'` и `'n'`, а `"\n"` – односимвольная строка, содержащая перевод строки. Регулярные выражения часто записываются в коде Python с использованием этой сырой строковой записи.157158Кроме того, специальные escape-последовательности, которые допустимы в регулярных выражениях, но не допустимы как строковые литералы Python, теперь приводят к [`SyntaxWarning`](https://python-all.ru/3.15/library/exceptions.html#SyntaxWarning) и со временем станут [`SyntaxError`](https://python-all.ru/3.15/library/exceptions.html#SyntaxError), то есть последовательности будут недействительны, если не использовать сырые строки или экранирование обратных косых черт.159160| Обычная строка | Сырая строка |161| --- | --- |162| `"ab*"` | `r"ab*"` |163| `"\\\\section"` | `r"\\section"` |164| `"\\w+\\s+\\1"` | `r"\w+\s+\1"` |165166### Выполнение сопоставлений167168Как только у вас есть объект, представляющий скомпилированное регулярное выражение, что с ним делать? Объекты Pattern имеют несколько методов и атрибутов. Здесь будут рассмотрены только самые важные; за полным списком обращайтесь к документации [`re`](https://python-all.ru/3.15/library/re.html#module-re).169170| Метод/Атрибут | Назначение |171| --- | --- |172| `search()` | Сканирует строку в поисках любого места, где данное регулярное выражение совпадает. |173| `prefixmatch()` | Определяет, совпадает ли РВ с началом строки. Ранее назывался [match()](https://python-all.ru/3.15/library/re.html#prefixmatch-vs-match). |174| `findall()` | Находит все подстроки, где совпадает РВ, и возвращает их в виде списка. |175| `finditer()` | Находит все подстроки, где совпадает РВ, и возвращает их в виде [итератора](https://python-all.ru/3.15/glossary.html#term-iterator). |176177[`search()`](https://python-all.ru/3.15/library/re.html#re.Pattern.search) и [`prefixmatch()`](https://python-all.ru/3.15/library/re.html#re.Pattern.prefixmatch) возвращают `None`, если совпадение не найдено. В случае успеха возвращается экземпляр [объекта совпадения](https://python-all.ru/3.15/library/re.html#match-objects), содержащий информацию о совпадении: где оно начинается и заканчивается, совпавшую подстроку и другое.178179Это можно изучить, интерактивно экспериментируя с модулем [`re`](https://python-all.ru/3.15/library/re.html#module-re).180181В данном HOWTO используется стандартный интерпретатор Python для примеров. Сначала запустите интерпретатор Python, импортируйте модуль [`re`](https://python-all.ru/3.15/library/re.html#module-re) и скомпилируйте регулярное выражение:182183```python184>>> import re185>>> p = re.compile('[a-z]+')186>>> p187re.compile('[a-z]+')188```189190Теперь можно попробовать сопоставить различные строки с РВ `[a-z]+`. Пустая строка не должна совпадать, поскольку `+` означает «одно или более повторений». [`search()`](https://python-all.ru/3.15/library/re.html#re.Pattern.search) в этом случае должен вернуть `None`, что заставит интерпретатор ничего не выводить. Можно явно напечатать результат `search()`, чтобы прояснить это.191192```python193>>> p.search("")194>>> print(p.search(""))195None196```197198Теперь попробуем на строке, которая должна совпадать, например `tempo`. В этом случае [`search()`](https://python-all.ru/3.15/library/re.html#re.Pattern.search) вернёт [объект совпадения](https://python-all.ru/3.15/library/re.html#match-objects), так что сохраните результат в переменную для последующего использования.199200```python201>>> m = p.search('tempo')202>>> m203<re.Match object; span=(0, 5), match='tempo'>204```205206Теперь можно запросить у [объекта совпадения](https://python-all.ru/3.15/library/re.html#match-objects) информацию о совпавшей строке. Экземпляры объекта совпадения также имеют несколько методов и атрибутов; наиболее важные:207208| Метод/Атрибут | Назначение |209| --- | --- |210| `group()` | Возвращает строку, совпавшую с РВ |211| `start()` | Возвращает начальную позицию совпадения |212| `end()` | Возвращает конечную позицию совпадения |213| `span()` | Возвращает кортеж с (начало, конец) позициями совпадения |214215Применение этих методов быстро прояснит их смысл:216217```python218>>> m.group()219'tempo'220>>> m.start(), m.end()221(0, 5)222>>> m.span()223(0, 5)224```225226[`group()`](https://python-all.ru/3.15/library/re.html#re.Match.group) возвращает подстроку, которая совпала с РВ. [`start()`](https://python-all.ru/3.15/library/re.html#re.Match.start) и [`end()`](https://python-all.ru/3.15/library/re.html#re.Match.end) возвращают начальный и конечный индекс совпадения. [`span()`](https://python-all.ru/3.15/library/re.html#re.Match.span) возвращает оба индекса в одном кортеже. Метод [`search()`](https://python-all.ru/3.15/library/re.html#re.Pattern.search) у шаблонов сканирует строку, поэтому совпадение может начинаться не с нуля. Однако метод [`prefixmatch()`](https://python-all.ru/3.15/library/re.html#re.Pattern.prefixmatch) проверяет только совпадение РВ с началом строки, так что `start()` в этом случае всегда будет равен нулю.227228```python229>>> m = p.search('::: message'); print(m)230<re.Match object; span=(4, 11), match='message'>231>>> m.group()232'message'233>>> m.span()234(4, 11)235>>> print(p.prefixmatch('::: message'))236None237```238239В реальных программах наиболее распространённый подход – сохранить [объект совпадения](https://python-all.ru/3.15/library/re.html#match-objects) в переменную, а затем проверить, был ли он `None`. Обычно это выглядит так:240241```python242p = re.compile( ... )243m = p.search( 'string goes here' )244if m:245    print('Match found: ', m.group())246else:247    print('No match')248```249250Два метода шаблонов возвращают все совпадения для шаблона. [`findall()`](https://python-all.ru/3.15/library/re.html#re.Pattern.findall) возвращает список совпавших строк:251252```python253>>> p = re.compile(r'\d+')254>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')255['12', '11', '10']256```257258Префикс `r`, делающий литерал сырой строкой, необходим в этом примере, потому что escape-последовательности в обычном «вареном» строковом литерале, которые не распознаются Python (в отличие от регулярных выражений), теперь приводят к [`SyntaxWarning`](https://python-all.ru/3.15/library/exceptions.html#SyntaxWarning) и со временем станут [`SyntaxError`](https://python-all.ru/3.15/library/exceptions.html#SyntaxError). См. [Проблему обратной косой черты](https://python-all.ru/3.15/howto/regex.html#the-backslash-plague).259260[`findall()`](https://python-all.ru/3.15/library/re.html#re.Pattern.findall) должен создать весь список, прежде чем его можно будет вернуть как результат. Метод [`finditer()`](https://python-all.ru/3.15/library/re.html#re.Pattern.finditer) возвращает последовательность экземпляров [объектов совпадения](https://python-all.ru/3.15/library/re.html#match-objects) в виде [итератора](https://python-all.ru/3.15/glossary.html#term-iterator):261262```python263>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')264>>> iterator265<callable_iterator object at 0x...>266>>> for match in iterator:267...     print(match.span())268...269(0, 2)270(22, 24)271(29, 31)272```273274### Функции уровня модуля275276Необязательно создавать объект шаблона и вызывать его методы; модуль [`re`](https://python-all.ru/3.15/library/re.html#module-re) также предоставляет функции верхнего уровня, называемые [`search()`](https://python-all.ru/3.15/library/re.html#re.search), [`prefixmatch()`](https://python-all.ru/3.15/library/re.html#re.prefixmatch), [`findall()`](https://python-all.ru/3.15/library/re.html#re.findall), [`sub()`](https://python-all.ru/3.15/library/re.html#re.sub) и так далее. Эти функции принимают те же аргументы, что и соответствующий метод шаблона, с добавлением строки РВ в качестве первого аргумента, и по-прежнему возвращают либо `None`, либо экземпляр [объекта совпадения](https://python-all.ru/3.15/library/re.html#match-objects).277278```python279>>> print(re.prefixmatch(r'From\s+', 'Fromage amk'))280None281>>> re.prefixmatch(r'From\s+', 'From amk Thu May 14 19:12:10 1998')282<re.Match object; span=(0, 5), match='From '>283```284285Под капотом эти функции просто создают объект шаблона и вызывают на нём соответствующий метод. Они также сохраняют скомпилированный объект в кеш, так что последующие вызовы с тем же РВ не будут каждый раз разбирать шаблон заново.286287Следует ли использовать функции уровня модуля или получать шаблон и вызывать его методы самостоятельно? При доступе к регулярному выражению внутри цикла предварительная компиляция позволит сэкономить несколько вызовов функций. Вне циклов, благодаря внутреннему кешу, разница невелика.288289### Флаги компиляции290291Флаги компиляции позволяют изменять некоторые аспекты работы регулярных выражений. Флаги доступны в модуле [`re`](https://python-all.ru/3.15/library/re.html#module-re) под двумя именами: длинным, например [`IGNORECASE`](https://python-all.ru/3.15/library/re.html#re.IGNORECASE), и коротким, однобуквенным, например [`I`](https://python-all.ru/3.15/library/re.html#re.I). (Для знакомых с модификаторами шаблонов Perl: однобуквенные формы используют те же буквы; например, короткая форма [`re.VERBOSE`](https://python-all.ru/3.15/library/re.html#re.VERBOSE) – это [`re.X`](https://python-all.ru/3.15/library/re.html#re.X).) Несколько флагов можно указать с помощью побитового ИЛИ; например, `re.I | re.M` устанавливает оба флага `I` и [`M`](https://python-all.ru/3.15/library/re.html#re.M).292293Ниже приведена таблица доступных флагов, а затем более подробное описание каждого из них.294295| Флаг | Значение |296| --- | --- |297| [`ASCII`](https://python-all.ru/3.15/library/re.html#re.ASCII), [`A`](https://python-all.ru/3.15/library/re.html#re.A) | Заставляет несколько управляющих последовательностей, таких как `\w`, `\b`, `\s` и `\d`, совпадать только с ASCII-символами с соответствующим свойством. |298| [`DOTALL`](https://python-all.ru/3.15/library/re.html#re.DOTALL), [`S`](https://python-all.ru/3.15/library/re.html#re.S) | Заставляет `.` совпадать с любым символом, включая символы новой строки. |299| [`IGNORECASE`](https://python-all.ru/3.15/library/re.html#re.IGNORECASE), [`I`](https://python-all.ru/3.15/library/re.html#re.I) | Выполняет регистронезависимое сопоставление. |300| [`LOCALE`](https://python-all.ru/3.15/library/re.html#re.LOCALE), [`L`](https://python-all.ru/3.15/library/re.html#re.L) | Выполняет сопоставление с учётом локали. |301| [`MULTILINE`](https://python-all.ru/3.15/library/re.html#re.MULTILINE), [`M`](https://python-all.ru/3.15/library/re.html#re.M) | Многострочное сопоставление, затрагивающее `^` и `$`. |302| [`VERBOSE`](https://python-all.ru/3.15/library/re.html#re.VERBOSE), [`X`](https://python-all.ru/3.15/library/re.html#re.X) (для ‘extended’). | Включает подробные (verbose) регулярные выражения, которые можно организовать более чисто и понятно. |303304#### `re.I`305306#### `re.IGNORECASE`307308Выполняет регистронезависимое сопоставление; классы символов и строковые литералы будут находить соответствия буквам без учёта регистра. Например, `[A-Z]` будет совпадать и со строчными буквами. Полное сопоставление Unicode также работает, если только флаг [`ASCII`](https://python-all.ru/3.15/library/re.html#re.ASCII) не отключает соответствие не-ASCII. Когда шаблоны Unicode `[a-z]` или `[A-Z]` используются в сочетании с флагом [`IGNORECASE`](https://python-all.ru/3.15/library/re.html#re.IGNORECASE), они будут совпадать с 52 ASCII-буквами и 4 дополнительными не-ASCII-буквами: ‘İ’ (U+0130, латинская заглавная буква I с точкой сверху), ‘ı’ (U+0131, латинская строчная буква без точки i), ‘ſ’ (U+017F, латинская строчная буква длинная s) и ‘K’ (U+212A, знак Кельвина). `Spam` будет совпадать с `'Spam'`, `'spam'`, `'spAM'` или `'ſpam'` (последнее совпадает только в режиме Unicode). Это приведение к нижнему регистру не учитывает текущую локаль; оно будет учитывать, если также установлен флаг [`LOCALE`](https://python-all.ru/3.15/library/re.html#re.LOCALE).309310#### `re.L`311312#### `re.LOCALE`313314Делает `\w`, `\W`, `\b`, `\B` и сопоставление без учёта регистра зависимыми от текущей локали вместо базы данных Unicode.315316Локали – это функция библиотеки C, предназначенная для помощи в написании программ, учитывающих языковые различия. Например, если вы обрабатываете закодированный французский текст, вам может понадобиться написать `\w+` для сопоставления слов, но `\w` сопоставляется только с классом символов `[A-Za-z]` в байтовых шаблонах; он не будет сопоставляться с байтами, соответствующими `é` или `ç`. Если ваша система настроена правильно и выбрана французская локаль, некоторые функции C сообщат программе, что байт, соответствующий `é`, также должен считаться буквой. Установка флага [`LOCALE`](https://python-all.ru/3.15/library/re.html#re.LOCALE) при компиляции регулярного выражения заставит скомпилированный объект использовать эти функции C для `\w`; это медленнее, но также позволяет `\w+` сопоставлять французские слова так, как вы ожидаете. Использование этого флага не рекомендуется в Python 3, поскольку механизм локали очень ненадёжен, одновременно обрабатывает только одну «культуру» и работает только с 8-битными локалями. Сопоставление с использованием Unicode уже включено по умолчанию в Python 3 для строковых (str) шаблонов, и оно способно обрабатывать разные локали/языки.317318#### `re.M`319320#### `re.MULTILINE`321322(`^` и `$` ещё не были объяснены; они будут представлены в разделе [Другие метасимволы](https://python-all.ru/3.15/howto/regex.html#more-metacharacters).)323324Обычно `^` сопоставляется только в начале строки, а `$` – только в конце строки и непосредственно перед символом новой строки (если он есть) в конце строки. Когда указан этот флаг, `^` сопоставляется в начале строки и в начале каждой строки внутри строки, сразу после каждого символа новой строки. Аналогично, метасимвол `$` сопоставляется в конце строки и в конце каждой строки (непосредственно перед каждым символом новой строки).325326#### `re.S`327328#### `re.DOTALL`329330Заставляет специальный символ `'.'` сопоставляться с любым символом, включая символ новой строки; без этого флага `'.'` будет сопоставляться с любым символом, *кроме* символа новой строки.331332#### `re.A`333334#### `re.ASCII`335336Заставляет `\w`, `\W`, `\b`, `\B`, `\s` и `\S` выполнять сопоставление только с ASCII вместо полного сопоставления с Unicode. Это имеет смысл только для строковых шаблонов и игнорируется для байтовых шаблонов.337338#### `re.X`339340#### `re.VERBOSE`341342Этот флаг позволяет писать более читаемые регулярные выражения, предоставляя больше гибкости в их форматировании. Когда этот флаг указан, пробелы в строке RE игнорируются, за исключением случаев, когда пробел находится внутри символьного класса или перед ним стоит неэкранированная обратная косая черта; это позволяет более чётко организовывать и форматировать RE. Также этот флаг позволяет помещать комментарии внутри RE, которые будут игнорироваться движком; комментарии отмечаются символом `'#'`, который не находится внутри символьного класса и перед которым нет неэкранированной обратной косой черты.343344Например, вот RE, использующий [`re.VERBOSE`](https://python-all.ru/3.15/library/re.html#re.VERBOSE); посмотрите, насколько его легче читать.345346```python347charref = re.compile(r"""348 &[#]                # Start of a numeric entity reference349 (350     0[0-7]+         # Octal form351   | [0-9]+          # Decimal form352   | x[0-9a-fA-F]+   # Hexadecimal form353 )354 ;                   # Trailing semicolon355""", re.VERBOSE)356```357358Без режима verbose регулярное выражение выглядело бы так:359360```python361charref = re.compile("&#(0[0-7]+"362                     "|[0-9]+"363                     "|x[0-9a-fA-F]+);")364```365366В примере выше автоматическая конкатенация строковых литералов Python использовалась, чтобы разбить RE на более мелкие части, но он всё равно сложнее для понимания, чем версия с [`re.VERBOSE`](https://python-all.ru/3.15/library/re.html#re.VERBOSE).367368## Больше возможностей шаблонов369370До сих пор мы рассмотрели только часть возможностей регулярных выражений. В этом разделе мы рассмотрим некоторые новые метасимволы и способы использования групп для извлечения частей сопоставленного текста.371372### Ещё метасимволы373374Остались некоторые метасимволы, которые мы ещё не рассмотрели. Большинство из них будет рассмотрено в этом разделе.375376Некоторые из оставшихся метасимволов – это *утверждения нулевой длины*. Они не заставляют движок продвигаться по строке; вместо этого они вообще не потребляют символов и просто возвращают успех или неудачу. Например, `\b` – это утверждение, что текущая позиция находится на границе слова; позиция при этом не меняется `\b` вообще. Это означает, что утверждения нулевой длины не следует повторять, потому что если они совпадают один раз в данной позиции, то они, очевидно, могут совпадать бесконечное число раз.377378**`|`**379380Альтернация, или оператор «или». Если *A* и *B* – регулярные выражения, то `A|B` совпадёт с любой строкой, которая соответствует либо *A*, либо *B*. У `|` очень низкий приоритет, чтобы он работал разумно при альтернации строк из нескольких символов. `Crow|Servo` совпадёт либо с `'Crow'`, либо с `'Servo'`, а не с `'Cro'`, `'w'` или `'S'`, и `'ervo'`.381382Чтобы сопоставить литерал `'|'`, используйте `\|` или заключите его в символьный класс, как в `[|]`.383384**`^`**385386Совпадение в начале строк. Если не установлен флаг [`MULTILINE`](https://python-all.ru/3.15/library/re.html#re.MULTILINE), соответствует только в начале строки. В режиме `MULTILINE` также совпадает сразу после каждого перевода строки внутри строки.387388Например, если требуется найти слово `From` только в начале строки, нужно использовать RE `^From`.389390```python391>>> print(re.search('^From', 'From Here to Eternity'))392<re.Match object; span=(0, 4), match='From'>393>>> print(re.search('^From', 'Reciting From Memory'))394None395```396397Чтобы сопоставить литерал `'^'`, используйте `\^`.398399**`$`**400401Совпадение в конце строки, которая определяется как конец строки или любая позиция, за которой следует символ перевода строки.402403```python404>>> print(re.search('}$', '{block}'))405<re.Match object; span=(6, 7), match='}'>406>>> print(re.search('}$', '{block} '))407None408>>> print(re.search('}$', '{block}\n'))409<re.Match object; span=(6, 7), match='}'>410```411412Чтобы сопоставить литерал `'$'`, используйте `\$` или заключите его в символьный класс, как в `[$]`.413414**`\A`**415416Совпадение только в начале строки. Вне режима [`MULTILINE`](https://python-all.ru/3.15/library/re.html#re.MULTILINE) `\A` и `^` фактически одинаковы. В режиме `MULTILINE` они различаются: `\A` по-прежнему совпадает только в начале строки, а `^` может совпадать в любом месте строки после символа перевода строки.417418**`\z`**419420Совпадение только в конце строки.421422**`\Z`**423424То же, что и `\z`. Для совместимости со старыми версиями Python.425426**`\b`**427428Граница слова. Это утверждение нулевой длины, которое совпадает только в начале или конце слова. Слово определяется как последовательность буквенно-цифровых символов, поэтому конец слова обозначается пробелом или не-буквенно-цифровым символом.429430Следующий пример находит `class` только когда это целое слово; он не совпадёт, если оно содержится внутри другого слова.431432```python433>>> p = re.compile(r'\bclass\b')434>>> print(p.search('no class at all'))435<re.Match object; span=(3, 8), match='class'>436>>> print(p.search('the declassified algorithm'))437None438>>> print(p.search('one subclass is'))439None440```441442Есть две тонкости, которые следует помнить при использовании этой специальной последовательности. Во-первых, это худшее столкновение между строковыми литералами Python и последовательностями регулярных выражений. В строковых литералах Python `\b` – это символ backspace, ASCII-код 8. Если не используются сырые строки, Python преобразует `\b` в backspace, и RE не будет совпадать так, как ожидается. Следующий пример выглядит так же, как предыдущий RE, но в нём опущен `'r'` перед строкой RE.443444```python445>>> p = re.compile('\bclass\b')446>>> print(p.search('no class at all'))447None448>>> print(p.search('\b' + 'class' + '\b'))449<re.Match object; span=(0, 7), match='\x08class\x08'>450```451452Во-вторых, внутри символьного класса, где это утверждение не используется, `\b` представляет символ backspace для совместимости со строковыми литералами Python.453454**`\B`**455456Ещё одно утверждение нулевой длины, противоположное `\b`, совпадает только когда текущая позиция не находится на границе слова.457458### Группировка459460Часто требуется получить больше информации, чем просто – совпало RE или нет. Регулярные выражения часто используются для разбора строк с помощью RE, разделённого на несколько подгрупп, каждая из которых соответствует интересующему компоненту. Например, строка заголовка RFC-822 разделена на имя заголовка и значение, разделённые `':'`, так:461462```text463From: author@example.com464User-Agent: Thunderbird 1.5.0.9 (X11/20061227)465MIME-Version: 1.0466To: editor@example.com467```468469Это можно обработать, написав регулярное выражение, которое сопоставляет всю строку заголовка, и имеет одну группу для имени заголовка и другую – для значения заголовка.470471Группы обозначаются метасимволами `'('`, `')'`. `'('` и `')'` имеют примерно тот же смысл, что и в математических выражениях; они группируют выражения, заключённые внутрь, и можно повторять содержимое группы с помощью квантификатора, такого как `*`, `+`, `?` или `{m,n}`. Например, `(ab)*` будет соответствовать нулю или более повторений `ab`.472473```python474>>> p = re.compile('(ab)*')475>>> print(p.search('ababababab').span())476(0, 10)477```478479Группы, обозначенные `'('`, `')'`, также захватывают начальный и конечный индексы сопоставленного текста; их можно получить, передав аргумент методам [`group()`](https://python-all.ru/3.15/library/re.html#re.Match.group), [`start()`](https://python-all.ru/3.15/library/re.html#re.Match.start), [`end()`](https://python-all.ru/3.15/library/re.html#re.Match.end) и [`span()`](https://python-all.ru/3.15/library/re.html#re.Match.span). Группы нумеруются начиная с 0. Группа 0 присутствует всегда; это всё RE, поэтому методы [объекта match](https://python-all.ru/3.15/library/re.html#match-objects) по умолчанию используют группу 0. Позже мы увидим, как задавать группы, которые не захватывают диапазон сопоставленного текста.480481```python482>>> p = re.compile('(a)b')483>>> m = p.search('ab')484>>> m.group()485'ab'486>>> m.group(0)487'ab'488```489490Подгруппы нумеруются слева направо, начиная с 1. Группы могут быть вложенными; чтобы определить номер, нужно просто посчитать открывающие скобки, идя слева направо.491492```python493>>> p = re.compile('(a(b)c)d')494>>> m = p.search('abcd')495>>> m.group(0)496'abcd'497>>> m.group(1)498'abc'499>>> m.group(2)500'b'501```502503[`group()`](https://python-all.ru/3.15/library/re.html#re.Match.group) можно передать несколько номеров групп одновременно, и в этом случае она вернёт кортеж, содержащий соответствующие значения для этих групп.504505```python506>>> m.group(2,1,2)507('b', 'abc', 'b')508```509510Метод [`groups()`](https://python-all.ru/3.15/library/re.html#re.Match.groups) возвращает кортеж, содержащий строки всех подгрупп, от 1 до их количества.511512```python513>>> m.groups()514('abc', 'b')515```516517Обратные ссылки в шаблоне позволяют указать, что содержимое ранее захваченной группы должно также присутствовать в текущей позиции строки. Например, `\1` будет успешным, если точное содержимое группы 1 можно найти в текущей позиции, иначе – нет. Помните, что строковые литералы Python также используют обратную косую черту с числами для включения произвольных символов в строку, поэтому обязательно используйте сырую строку при включении обратных ссылок в RE.518519Например, следующее RE обнаруживает удвоенные слова в строке.520521```python522>>> p = re.compile(r'\b(\w+)\s+\1\b')523>>> p.search('Paris in the the spring').group()524'the the'525```526527Обратные ссылки такого рода редко бывают полезны при простом поиске в строке – существует мало текстовых форматов, которые повторяют данные таким образом, – но вскоре обнаруживается, что они *очень* полезны при выполнении строковых подстановок.528529### Незахватывающие и именованные группы530531Сложные регулярные выражения могут использовать много групп как для захвата интересующих подстрок, так и для группировки и структурирования самого выражения. В сложных RE становится трудно отслеживать номера групп. Существуют две возможности, которые помогают решить эту проблему. Обе используют общий синтаксис расширений регулярных выражений, поэтому сначала рассмотрим его.532533Perl 5 хорошо известен своими мощными дополнениями к стандартным регулярным выражениям. Для этих новых возможностей разработчики Perl не могли выбрать новые метасимволы из одного символа или новые специальные последовательности, начинающиеся с `\`, не сделав регулярные выражения Perl запутанно отличающимися от стандартных RE. Если бы они выбрали `&` в качестве нового метасимвола, например, старые выражения предполагали бы, что `&` – это обычный символ, и не экранировали бы его, записывая `\&` или `[&]`.534535Разработчики Perl выбрали `(?...)` в качестве синтаксиса расширения. `?` сразу после круглой скобки был синтаксической ошибкой, потому что `?` нечего было бы повторять, так что это не вызвало проблем совместимости. Символы сразу после `?` указывают, какое расширение используется, так что `(?=foo)` – это одно (положительная опережающая проверка), а `(?:foo)` – другое (незахватывающая группа, содержащая подвыражение `foo`).536537Python поддерживает несколько расширений Perl и добавляет собственный синтаксис расширений к синтаксису расширений Perl. Если первый символ после вопросительного знака – `P`, то это расширение, специфичное для Python.538539Теперь, когда мы рассмотрели общий синтаксис расширений, можно вернуться к возможностям, упрощающим работу с группами в сложных RE.540541Иногда требуется использовать группу для обозначения части регулярного выражения, но нет необходимости извлекать содержимое группы. Это можно явно указать с помощью незахватывающей группы: `(?:...)`, где `...` можно заменить любым другим регулярным выражением.542543```python544>>> m = re.search("([abc])+", "abc")545>>> m.groups()546('c',)547>>> m = re.search("(?:[abc])+", "abc")548>>> m.groups()549()550```551552За исключением того, что нельзя извлечь содержимое того, что сопоставила группа, незахватывающая группа ведёт себя точно так же, как захватывающая: в неё можно поместить что угодно, повторить её с помощью метасимвола повторения, такого как `*`, и вложить в другие группы (захватывающие или незахватывающие). `(?:...)` особенно полезен при изменении существующего шаблона, поскольку можно добавлять новые группы, не меняя нумерацию всех остальных групп. Стоит упомянуть, что нет разницы в производительности поиска между захватывающими и незахватывающими группами; ни одна из форм не быстрее другой.553554Более значимая возможность – именованные группы: вместо обращения по номерам группы можно ссылаться по имени.555556Синтаксис именованной группы – одно из расширений, специфичных для Python: `(?P<name>...)`. *name* – это, очевидно, имя группы. Именованные группы ведут себя точно так же, как захватывающие, и дополнительно связывают имя с группой. Методы [объекта match](https://python-all.ru/3.15/library/re.html#match-objects), которые работают с захватывающими группами, принимают как целые числа, обозначающие группу по номеру, так и строки, содержащие имя нужной группы. Именованные группы по-прежнему имеют номера, поэтому информацию о группе можно получить двумя способами:557558```python559>>> p = re.compile(r'(?P<word>\b\w+\b)')560>>> m = p.search( '(((( Lots of punctuation )))' )561>>> m.group('word')562'Lots'563>>> m.group(1)564'Lots'565```566567Кроме того, можно получить именованные группы в виде словаря с помощью [`groupdict()`](https://python-all.ru/3.15/library/re.html#re.Match.groupdict):568569```python570>>> m = re.search(r'(?P<first>\w+) (?P<last>\w+)', 'Jane Doe')571>>> m.groupdict()572{'first': 'Jane', 'last': 'Doe'}573```574575Именованные группы удобны, потому что позволяют использовать легко запоминающиеся имена вместо запоминания номеров. Вот пример RE из модуля [`imaplib`](https://python-all.ru/3.15/library/imaplib.html#module-imaplib):576577```python578InternalDate = re.compile(r'INTERNALDATE "'579        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'580        r'(?P<year>[0-9][0-9][0-9][0-9])'581        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'582        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'583        r'"')584```585586Очевидно, что гораздо проще получить `m.group('zonem')`, чем запоминать, что нужно получить группу 9.587588Синтаксис обратных ссылок в выражении, таком как `(...)\1`, относится к номеру группы. Естественно, существует вариант, использующий имя группы вместо номера. Это ещё одно расширение Python: `(?P=name)` указывает, что содержимое группы с именем *name* должно снова совпадать в текущей позиции. Регулярное выражение для поиска удвоенных слов, `\b(\w+)\s+\1\b`, можно также записать как `\b(?P<word>\w+)\s+(?P=word)\b`:589590```python591>>> p = re.compile(r'\b(?P<word>\w+)\s+(?P=word)\b')592>>> p.search('Paris in the the spring').group()593'the the'594```595596### Опережающие проверки597598Ещё одна проверка нулевой ширины – опережающая проверка. Опережающие проверки бывают положительными и отрицательными и выглядят так:599600**`(?=...)`**601602Положительная опережающая проверка. Она успешна, если вложенное регулярное выражение, представленное здесь как `...`, успешно совпадает в текущей позиции, и неуспешна в противном случае. Но как только вложенное выражение проверено, движок сопоставления не продвигается; остальная часть шаблона проверяется прямо с того места, где началась проверка.603604**`(?!...)`**605606Отрицательная опережающая проверка. Это противоположность положительной проверке; она успешна, если вложенное выражение *не* совпадает в текущей позиции строки.607608Чтобы сделать это конкретным, рассмотрим случай, где опережающая проверка полезна. Рассмотрим простой шаблон для сопоставления имени файла и разделения его на базовое имя и расширение, разделённых точкой `.`. Например, в `news.rc` `news` – это базовое имя, а `rc` – расширение файла.609610Шаблон для сопоставления этого довольно прост:611612`.*[.].*$`613614Обратите внимание, что `.` нужно обрабатывать особым образом, потому что это метасимвол, поэтому он помещён в символьный класс, чтобы сопоставлять только этот конкретный символ. Также обратите внимание на завершающий `$`; он добавлен, чтобы гарантировать, что вся оставшаяся часть строки входит в расширение. Это регулярное выражение сопоставляется с `foo.bar`, `autoexec.bat`, `sendmail.cf` и `printers.conf`.615616Теперь усложним задачу: что, если нужно сопоставить имена файлов, расширение которых не равно `bat`? Некоторые неверные попытки:617618`.*[.][^b].*$`619620Первая попытка выше пытается исключить `bat`, требуя, чтобы первый символ расширения не был `b`. Это неправильно, потому что шаблон также не сопоставляется с `foo.bar`.621622`.*[.]([^b]..|.[^a].|..[^t])$`623624Выражение становится более запутанным, если попытаться исправить первое решение, потребовав совпадения одного из следующих случаев: первый символ расширения не `b`; второй символ не `a`; или третий символ не `t`. Это принимает `foo.bar` и отвергает `autoexec.bat`, но требует трёхбуквенного расширения и не принимает имя файла с двухбуквенным расширением, например `sendmail.cf`. Мы снова усложним шаблон, пытаясь это исправить.625626`.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$`627628В третьей попытке вторая и третья буквы сделаны необязательными, чтобы разрешить сопоставление расширений короче трёх символов, например `sendmail.cf`.629630Шаблон становится очень сложным, что затрудняет его чтение и понимание. Хуже того, если задача изменится и потребуется исключить как `bat`, так и `exe` в качестве расширений, шаблон станет ещё более запутанным и сложным.631632Отрицательная опережающая проверка разрешает всю эту путаницу:633634`.*[.](?!bat$)[^.]*$`635636Отрицательная опережающая проверка означает: если выражение `bat` не совпадает в этой точке, то проверяется остальная часть шаблона; если `bat$` совпадает, весь шаблон завершится неудачей. Завершающий `$` нужен, чтобы гарантировать, что такие случаи, как `sample.batch`, где расширение только начинается с `bat`, будут разрешены. `[^.]*` обеспечивает работу шаблона, когда в имени файла несколько точек.637638Исключить другое расширение файла теперь легко: просто добавьте его как альтернативу внутри проверки. Следующий шаблон исключает имена файлов, которые заканчиваются на `bat` или `exe`:639640`.*[.](?!bat$|exe$)[^.]*$`641642## Изменение строк643644До этого момента мы просто выполняли поиск в статической строке. Регулярные выражения также часто используются для изменения строк различными способами с помощью следующих методов шаблона:645646| Метод/Атрибут | Назначение |647| --- | --- |648| `split()` | Разделяет строку на список, разбивая её везде, где совпадает RE |649| `sub()` | Находит все подстроки, совпадающие с RE, и заменяет их на другую строку |650| `subn()` | Делает то же самое, что `sub()`, но возвращает новую строку и количество замен |651652### Разбиение строк653654Метод [`split()`](https://python-all.ru/3.15/library/re.html#re.Pattern.split) шаблона разделяет строку везде, где совпадает RE, возвращая список частей. Он похож на метод [`split()`](https://python-all.ru/3.15/library/stdtypes.html#str.split) строк, но предоставляет гораздо большую гибкость в разделителях, по которым можно разбивать; строковый `split()` поддерживает разбиение только по пробельным символам или по фиксированной строке. Как и следовало ожидать, существует также функция уровня модуля [`re.split()`](https://python-all.ru/3.15/library/re.html#re.split).655656#### `.split(string[, maxsplit=0])`657658Разделяет *строку* по совпадениям регулярного выражения. Если в RE используются захватывающие круглые скобки, то их содержимое также будет возвращено как часть результирующего списка. Если *maxsplit* не равно нулю, выполняется не более *maxsplit* разбиений.659660Количество выполняемых разбиений можно ограничить, передав значение для *maxsplit*. Если *maxsplit* не равно нулю, будет выполнено не более *maxsplit* разбиений, а остаток строки возвращается как последний элемент списка. В следующем примере разделителем является любая последовательность неалфавитно-цифровых символов.661662```python663>>> p = re.compile(r'\W+')664>>> p.split('This is a test, short and sweet, of split().')665['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']666>>> p.split('This is a test, short and sweet, of split().', 3)667['This', 'is', 'a', 'test, short and sweet, of split().']668```669670Иногда нужно знать не только текст между разделителями, но и сам разделитель. Если в RE используются захватывающие круглые скобки, то их значения также возвращаются как часть списка. Сравните следующие вызовы:671672```python673>>> p = re.compile(r'\W+')674>>> p2 = re.compile(r'(\W+)')675>>> p.split('This... is a test.')676['This', 'is', 'a', 'test', '']677>>> p2.split('This... is a test.')678['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']679```680681Функция уровня модуля [`re.split()`](https://python-all.ru/3.15/library/re.html#re.split) добавляет RE, используемый как первый аргумент, но в остальном идентична.682683```python684>>> re.split(r'[\W]+', 'Words, words, words.')685['Words', 'words', 'words', '']686>>> re.split(r'([\W]+)', 'Words, words, words.')687['Words', ', ', 'words', ', ', 'words', '.', '']688>>> re.split(r'[\W]+', 'Words, words, words.', 1)689['Words', 'words, words.']690```691692### Поиск и замена693694Ещё одна распространённая задача – найти все совпадения с шаблоном и заменить их другой строкой. Метод [`sub()`](https://python-all.ru/3.15/library/re.html#re.Pattern.sub) принимает значение замены, которое может быть строкой или функцией, и обрабатываемую строку.695696#### `.sub(replacement, string[, count=0])`697698Возвращает строку, полученную заменой самых левых непересекающихся совпадений RE в *строке* на замену *replacement*. Если шаблон не найден, *строка* возвращается без изменений.699700Необязательный аргумент *count* – максимальное количество заменяемых вхождений шаблона; *count* должно быть неотрицательным целым числом. Значение по умолчанию 0 означает замену всех вхождений.701702Вот простой пример использования метода [`sub()`](https://python-all.ru/3.15/library/re.html#re.Pattern.sub). Он заменяет названия цветов словом `colour`:703704```python705>>> p = re.compile('(blue|white|red)')706>>> p.sub('colour', 'blue socks and red shoes')707'colour socks and colour shoes'708>>> p.sub('colour', 'blue socks and red shoes', count=1)709'colour socks and red shoes'710```711712Метод [`subn()`](https://python-all.ru/3.15/library/re.html#re.Pattern.subn) делает то же самое, но возвращает кортеж из двух элементов, содержащий новую строку и количество выполненных замен:713714```python715>>> p = re.compile('(blue|white|red)')716>>> p.subn('colour', 'blue socks and red shoes')717('colour socks and colour shoes', 2)718>>> p.subn('colour', 'no colours at all')719('no colours at all', 0)720```721722Пустые совпадения заменяются только тогда, когда они не примыкают к предыдущему пустому совпадению.723724```python725>>> p = re.compile('x*')726>>> p.sub('-', 'abxd')727'-a-b--d-'728```729730Если *replacement* является строкой, все escape-последовательности с обратной косой чертой обрабатываются. То есть `\n` преобразуется в символ новой строки, `\r` – в возврат каретки и так далее. Неизвестные escape-последовательности, такие как `\&`, остаются без изменений. Обратные ссылки, например `\6`, заменяются подстрокой, совпавшей с соответствующей группой в регулярном выражении. Это позволяет включать части исходного текста в результирующую строку замены.731732В этом примере ищется слово `section`, за которым следует строка, заключённая в `{`, `}`, и `section` заменяется на `subsection`:733734```python735>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)736>>> p.sub(r'subsection{\1}','section{First} section{second}')737'subsection{First} subsection{second}'738```739740Существует также синтаксис для ссылки на именованные группы, определённые с помощью синтаксиса `(?P<name>...)`. `\g<name>` будет использовать подстроку, совпавшую с группой с именем `name`, а `\g<number>` использует соответствующий номер группы. Таким образом, `\g<2>` эквивалентно `\2`, но не является неоднозначным в строке замены, такой как `\g<2>0`. (`\20` было бы интерпретировано как ссылка на группу 20, а не как ссылка на группу 2, за которой следует литеральный символ `'0'`.) Следующие подстановки эквивалентны, но используют все три варианта строки замены.741742```python743>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)744>>> p.sub(r'subsection{\1}','section{First}')745'subsection{First}'746>>> p.sub(r'subsection{\g<1>}','section{First}')747'subsection{First}'748>>> p.sub(r'subsection{\g<name>}','section{First}')749'subsection{First}'750```751752*replacement* также может быть функцией, что даёт ещё больше контроля. Если *replacement* является функцией, она вызывается для каждого непересекающегося вхождения *pattern*. При каждом вызове функции передаётся аргумент [объект совпадения](https://python-all.ru/3.15/library/re.html#match-objects) и она может использовать эту информацию для вычисления нужной строки замены и возврата её.753754В следующем примере функция замены преобразует десятичные числа в шестнадцатеричные:755756```python757>>> def hexrepl(match):758...     "Return the hex string for a decimal number"759...     value = int(match.group())760...     return hex(value)761...762>>> p = re.compile(r'\d+')763>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')764'Call 0xffd2 for printing, 0xc000 for user code.'765```766767При использовании функции уровня модуля [`re.sub()`](https://python-all.ru/3.15/library/re.html#re.sub) шаблон передаётся как первый аргумент. Шаблон может быть предоставлен как объект или как строка; если нужно указать флаги регулярного выражения, необходимо либо использовать объект шаблона в качестве первого параметра, либо использовать встроенные модификаторы в строке шаблона, например `sub("(?i)b+", "x", "bbbb BBBB")` возвращает `'x x'`.768769## Распространённые проблемы770771Регулярные выражения – мощный инструмент для некоторых приложений, но в некоторых аспектах их поведение не интуитивно и иногда они ведут себя не так, как можно было бы ожидать. В этом разделе будут указаны некоторые наиболее распространённые ошибки.772773### Использование строковых методов774775Иногда использование модуля [`re`](https://python-all.ru/3.15/library/re.html#module-re) является ошибкой. Если производится сопоставление с фиксированной строкой или одиночным классом символов и не используются никакие возможности `re`, такие как флаг [`IGNORECASE`](https://python-all.ru/3.15/library/re.html#re.IGNORECASE), то вся мощь регулярных выражений может не понадобиться. Строки имеют несколько методов для выполнения операций с фиксированными строками, и они обычно намного быстрее, поскольку реализация представляет собой один небольшой цикл на C, оптимизированный для этой цели, а не большой, более обобщённый движок регулярных выражений.776777Примером может быть замена одной фиксированной строки на другую; например, можно заменить `word` на `deed`. [`re.sub()`](https://python-all.ru/3.15/library/re.html#re.sub) кажется подходящей функцией для этого, но рассмотрите метод [`replace()`](https://python-all.ru/3.15/library/stdtypes.html#str.replace). Обратите внимание, что `replace()` также заменит `word` внутри слов, превратив `swordfish` в `sdeedfish`, но наивное RE `word` сделало бы то же самое. (Чтобы избежать замены в частях слов, шаблон должен быть `\bword\b`, чтобы требовать, чтобы `word` имело границу слова с обеих сторон. Это выходит за рамки возможностей `replace()`.)778779Ещё одна распространённая задача – удаление всех вхождений одного символа из строки или замена его другим символом. Можно сделать это с помощью чего-то вроде `re.sub('\n', ' ', S)`, но [`translate()`](https://python-all.ru/3.15/library/stdtypes.html#str.translate) способен выполнить обе задачи и будет быстрее любой операции с регулярными выражениями.780781Короче говоря, прежде чем обращаться к модулю [`re`](https://python-all.ru/3.15/library/re.html#module-re), подумайте, не решается ли ваша задача более быстрым и простым строковым методом.782783### prefixmatch() (также известный как match) и search()784785[`prefixmatch()`](https://python-all.ru/3.15/library/re.html#re.prefixmatch) был добавлен в Python 3.15 как [предпочтительное имя](https://python-all.ru/3.15/library/re.html#prefixmatch-vs-match) для [`match()`](https://python-all.ru/3.15/library/re.html#re.match). До этого он был известен только как `match()`, и различие с [`search()`](https://python-all.ru/3.15/library/re.html#re.search) часто неправильно понимали.786787`prefixmatch()` (также `match()`) проверяет только, совпадает ли RE в начале строки, тогда как `search()` просматривает строку вперёд в поисках совпадения.788789```python790>>> print(re.prefixmatch('super', 'superstition').span())791(0, 5)792>>> print(re.prefixmatch('super', 'insuperable'))793None794```795796С другой стороны, [`search()`](https://python-all.ru/3.15/library/re.html#re.search) просматривает строку вперёд, сообщая о первом найденном совпадении.797798```python799>>> print(re.search('super', 'superstition').span())800(0, 5)801>>> print(re.search('super', 'insuperable').span())802(2, 7)803```804805Это различие важно помнить при использовании старого имени [`match()`](https://python-all.ru/3.15/library/re.html#re.match) в коде, требующем совместимости со старыми версиями Python.806807### Жадные и нежадные квантификаторы808809При повторении регулярного выражения, как в `a*`, результатом является потребление как можно большей части шаблона. Этот факт часто подводит, когда пытаются сопоставить пару сбалансированных разделителей, например, угловые скобки, окружающие HTML-тег. Наивный шаблон для сопоставления одного HTML-тега не работает из-за жадной природы `.*`.810811```python812>>> s = '<html><head><title>Title</title>'813>>> len(s)81432815>>> print(re.prefixmatch('<.*>', s).span())816(0, 32)817>>> print(re.prefixmatch('<.*>', s).group())818<html><head><title>Title</title>819```820821RE находит `'<'` в `'<html>'`, а `.*` поглощает остаток строки. Однако в RE остаётся ещё часть, и `>` не может совпасть в конце строки, поэтому движку регулярных выражений приходится возвращаться посимвольно, пока он не найдёт совпадение для `>`. Итоговое совпадение простирается от `'<'` в `'<html>'` до `'>'` в `'</title>'`, что не то, что нужно.822823В этом случае решение – использовать нежадные квантификаторы `*?`, `+?`, `??` или `{m,n}?`, которые находят *как можно меньше* текста. В приведённом примере `'>'` пробуется сразу после того, как совпадает первый `'<'`, и если это не удаётся, движок продвигается по одному символу, повторно пробуя `'>'` на каждом шаге. Это даёт правильный результат:824825```python826>>> print(re.prefixmatch('<.*?>', s).group())827<html>828```829830(Заметьте, что разбор HTML или XML с помощью регулярных выражений – дело мучительное. Быстрые и грязные шаблоны справятся с обычными случаями, но у HTML и XML есть особые случаи, которые сломают очевидное регулярное выражение; к тому времени, как вы напишете регулярное выражение, обрабатывающее все возможные случаи, шаблоны станут *очень* сложными. Используйте для таких задач модуль разбора HTML или XML.)831832### Использование re.VERBOSE833834К этому моменту вы, вероятно, заметили, что регулярные выражения – это очень компактная запись, но они не слишком читаемы. RE умеренной сложности могут превратиться в длинные наборы обратных слешей, скобок и метасимволов, что затрудняет их чтение и понимание.835836Для таких RE указание флага [`re.VERBOSE`](https://python-all.ru/3.15/library/re.html#re.VERBOSE) при компиляции регулярного выражения может быть полезно, поскольку позволяет форматировать регулярное выражение более чётко.837838Флаг `re.VERBOSE` имеет несколько эффектов. Пробельные символы в регулярном выражении, которые *не находятся* внутри символьного класса, игнорируются. Это означает, что выражение вида `dog | cat` эквивалентно менее читаемому `dog|cat`, но `[a b]` по-прежнему будет соответствовать символам `'a'`, `'b'` или пробелу. Кроме того, в RE можно вставлять комментарии; комментарии начинаются с символа `#` и продолжаются до следующей новой строки. При использовании с тройными кавычками это позволяет форматировать RE более аккуратно:839840```python841pat = re.compile(r"""842 \s*                 # Skip leading whitespace843 (?P<header>[^:]+)   # Header name844 \s* :               # Whitespace, and a colon845 (?P<value>.*?)      # The header's value -- *? used to846                     # lose the following trailing whitespace847 \s*$                # Trailing whitespace to end-of-line848""", re.VERBOSE)849```850851Это гораздо читаемее, чем:852853```python854pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")855```856857## Обратная связь858859Регулярные выражения – сложная тема. Помог ли вам этот документ понять их? Были ли неясные части или проблемы, которые здесь не были рассмотрены? Если да, пожалуйста, отправьте предложения по улучшению в [трекер проблем](https://python-all.ru/3.15/bugs.html#using-the-tracker).860861Наиболее полной книгой по регулярным выражениям, пожалуй, является \*Mastering Regular Expressions\* Джеффри Фридла, издательство O’Reilly. К сожалению, она сосредоточена исключительно на разновидностях регулярных выражений Perl и Java и вообще не содержит материала по Python, так что она не пригодится в качестве справочника по программированию на Python. (В первом издании рассматривался модуль `regex`, который теперь удалён из Python, что вам не сильно поможет.) Рекомендуем взять её в библиотеке.862