re — Операции с регулярными выражениями

Kod źródłowy: Lib/re/

---

Цей модуль забезпечує операції зіставлення регулярних виразів, подібні до тих, які є в Perl.

Как шаблоны, так и строки для поиска могут быть строками Юникода (str), а также 8-битными строками (bytes). Однако строки Юникода и 8-битные строки нельзя смешивать: то есть нельзя сопоставить строку Юникода с шаблоном байтов или наоборот; аналогично, при запросе замены строка замены должна быть того же типа, что и шаблон, и строка поиска.

Регулярные выражения используют символ обратной косой черты ('\') для обозначения специальных форм или для разрешения использования специальных символов без обращения к их особому значению. Это противоречит использованию Python того же символа для той же цели в строковых литералах; например, чтобы сопоставить буквальную обратную косую черту, возможно, придется написать '\\\\' в качестве строки шаблона, поскольку регулярное выражение должно быть \\, а каждая обратная косая черта должна быть выражена как \\\, а каждая обратная косая черта должна быть выражена как '\\\\' в качестве строки шаблона \` внутри обычного строкового литерала Python. Также обратите внимание, что любые недопустимые escape-последовательности при использовании Python обратной косой черты в строковых литералах теперь генерируют SyntaxWarning, а в будущем это станет SyntaxError. Такое поведение произойдет, даже если это допустимая escape-последовательность для регулярного выражения.

Рішення полягає у використанні необробленої рядкової нотації Python для шаблонів регулярних виразів; зворотні косі риски не обробляються жодним особливим чином у рядковому літералі з префіксом 'r'. Отже, r"\n" — це двосимвольний рядок, що містить '\' і 'n', тоді як "\n" є односимвольним рядком, що містить новий рядок. Зазвичай шаблони виражаються в коді Python за допомогою цієї необробленої рядкової нотації.

Важливо відзначити, що більшість операцій з регулярними виразами доступні як функції та методи на рівні модуля для компільованих регулярних виразів. Функції — це ярлики, які не потребують компіляції об’єкта регулярного виразу, але пропускають деякі параметри тонкого налаштування.

Zobacz także

Сторонний модуль regex, имеющий API, совместимый со стандартным модулем библиотеки re, но предлагающий дополнительную функциональность и более полную поддержку Unicode.

Синтаксис регулярного виразу

Регулярний вираз (або RE) визначає набір рядків, який йому відповідає; функції в цьому модулі дозволяють вам перевірити, чи збігається певний рядок з даним регулярним виразом (або чи збігається даний регулярний вираз з певним рядком, що зводиться до того самого).

Регулярні вирази можна об’єднувати для створення нових регулярних виразів; якщо A і B є регулярними виразами, то AB також є регулярним виразом. Загалом, якщо рядок p відповідає A, а інший рядок q відповідає B, рядок pq відповідатиме AB. Це справедливо, якщо A або B не містять операції з низьким пріоритетом; граничні умови між A і B; або мають пронумеровані посилання на групи. Таким чином, складні вирази можна легко побудувати з простіших примітивних виразів, таких як описані тут. Щоб отримати детальну інформацію про теорію та реалізацію регулярних виразів, зверніться до книги Фрідла [Frie09] або майже до будь-якого підручника про побудову компілятора.

Нижче наведено коротке пояснення формату регулярних виразів. Для отримання додаткової інформації та більш щадної презентації зверніться до Wyrażenia regularne PORADNIK.

Регулярні вирази можуть містити як спеціальні, так і звичайні символи. Більшість звичайних символів, таких як 'A', 'a' або '0', є найпростішими регулярними виразами; вони просто збігаються. Ви можете об’єднувати звичайні символи, тому last збігається з рядком 'last'. (У решті цього розділу ми будемо писати RE в цим особливим стилі, як правило, без лапок, а рядки для відповідності 'в одинарних лапках.)

Деякі символи, наприклад '|' або '('', є спеціальними. Спеціальні символи або позначають класи звичайних символів, або впливають на інтерпретацію регулярних виразів навколо них.

Операторы повторения или квантификаторы (*, +, ?, {m,n} и т. д.) не могут быть вложены напрямую. Это позволяет избежать двусмысленности с нежадным суффиксом модификатора ? и с другими модификаторами в других реализациях. Чтобы применить второе повторение к внутреннему повторению, можно использовать круглые скобки. Например, выражение (?:a{6})* соответствует любому числу символов, кратному шести 'a'.

Спеціальними символами є:

.

(Точка.) В режиме по умолчанию соответствует любому символу, кроме символа новой строки. Если указан флаг DOTALL, он соответствует любому символу, включая символ новой строки. (?s:.) соответствует любому символу независимо от флагов.

^

(Caret.) Збігається з початком рядка, а в режимі MULTILINE також збігається одразу після кожного нового рядка.

$

Збігається з кінцем рядка або безпосередньо перед символом нового рядка в кінці рядка, а в режимі MULTILINE також збігається перед символом нового рядка. foo відповідає як «foo», так і «foobar», тоді як регулярний вираз foo$ відповідає лише «foo». Що ще цікавіше, пошук foo.$ у 'foo1\nfoo2\n'' зазвичай відповідає «foo2», але «foo1» у режимі MULTILINE; пошук одного $ у 'foo\n' знайде два (порожні) збіги: один безпосередньо перед символом нового рядка та один у кінці рядка.

*

Примушує кінцевий RE відповідати 0 або більше повторень попереднього RE, якомога більше повторень. ab* відповідатиме «a», «ab» або «a», за якими йде будь-яка кількість «b».

+

Примушує кінцевий RE відповідати 1 або більше повторень попереднього RE. ab+ відповідатиме «a», за яким слідує будь-яке ненульове число «b»; воно не збігатиметься лише з „а”.

?

Примушує результуюче RE відповідати 0 або 1 повторенням попереднього RE. ab? відповідатиме або «a», або «ab».

*?, +?, ??

Кванторы '*', '+' и '?' являются greedy; они соответствуют как можно большему количеству текста. Иногда такое поведение нежелательно; если RE <.*> сопоставляется с '<a> b <c>', он будет соответствовать всей строке, а не только '<a>'. Добавление ? после квантора заставляет его выполнять сопоставление в нежадном или минимальном режиме; будет совпадать как можно немногие символы. Использование RE <.*?> будет соответствовать только '<a>'.

*+, ++, ?+

Подобно квантификаторам '*', '+' и '?', те, к которым добавлен '+', также совпадают столько раз, сколько возможно. Однако, в отличие от настоящих жадных квантификаторов, они не позволяют выполнять обратный поиск, если следующее за ним выражение не соответствует. Они известны как кванторы притяжательные. Например, a*a будет соответствовать 'aaaa', потому что a* будет соответствовать всем 4 'a's, но когда последний 'a встречается ', выражение возвращается так, что в конце концов a* соответствует 3 'a's, а четвертому 'a' соответствует последнее 'а'. Однако, когда a*+a используется для соответствия 'aaaa', a*+ будет соответствовать всем 4 'a', но когда последний ' a' не может найти больше символов для соответствия, выражение не может быть возвращено и, следовательно, не будет соответствовать. x*+, x++ и x?+ эквивалентны (?>x*), (?>x+) и (?> x?) соответственно.

Dodane w wersji 3.11.

{m}

Вказує, що точно m копій попереднього RE мають відповідати; менша кількість збігів призводить до того, що весь RE не збігається. Наприклад, a{6} відповідатиме рівно шести символам 'a', але не п’яти.

{m,n}

Примушує результуючий RE відповідати від m до n повторень попереднього RE, намагаючись зіставити якомога більше повторень. Наприклад, a{3,5} відповідатиме від 3 до 5 символів 'a'. Пропуск m визначає нижню межу нуля, а пропуск n визначає нескінченну верхню межу. Наприклад, a{4,}b відповідатиме 'aaaab' або тисячі символів 'a', після яких 'b', але не ' аааб''. Кому не можна опускати, інакше модифікатор можна сплутати з попередньо описаною формою.

{m,n}?

Заставляет результирующий RE соответствовать от m до n повторений предыдущего RE, пытаясь сопоставить как можно несколько повторений. Это нежадная версия предыдущего квантора. Например, в строке из 6 символов 'aaaaaa' a{3,5} будет соответствовать 5 символам 'a', а ``a{3,5}?` ` будет соответствовать только 3 символам.

{m,n}+

Заставляет результирующий RE соответствовать от m до n повторений предыдущего RE, пытаясь сопоставить как можно больше повторений без установления каких-либо точек возврата. Это притяжательная версия приведенного выше квантора. Например, в строке из 6 символов 'aaaaaa' a{3,5}+aa попытается сопоставить 5 символов 'a', затем потребуется еще 2 ' a's, потребуется больше символов, чем доступно, и, следовательно, произойдет сбой, в то время как a{3,5}aa будет соответствовать a{3,5}, захватывая 5, а затем 4 ' a's путем возврата, а затем последние 2 'a's сопоставляются с последним aa в шаблоне. x{m,n}+ эквивалентно (?>x{m,n}).

Dodane w wersji 3.11.

\

Або екранує спеціальні символи (дозволяючи вам зіставляти такі символи, як '*', '?'' і так далі), або сигналізує про спеціальну послідовність; спеціальні послідовності обговорюються нижче.

Якщо ви не використовуєте необроблений рядок для вираження шаблону, пам’ятайте, що Python також використовує зворотну косу риску як керуючу послідовність у рядкових літералах; якщо escape-послідовність не розпізнається синтаксичним аналізатором Python, зворотна коса риска та наступний символ включаються в результуючий рядок. Однак, якщо Python розпізнає отриману послідовність, зворотну косу риску слід повторити двічі. Це складно і важко зрозуміти, тому настійно рекомендується використовувати необроблені рядки для всіх виразів, крім найпростіших.

[]

Використовується для позначення набору символів. В комплекті:

• Символи можуть бути перераховані окремо, напр. „[amk]” відповідатиме „a”, „m” або „k”.

• Діапазони символів можна вказати, вказавши два символи та розділивши їх символом '-', наприклад, [a-z] відповідатиме будь-якій літері ASCII у нижньому регістрі, [0-5][0-9]. ] відповідатиме всім двозначним числам від 00 до 59, а [0-9A-Fa-f] відповідатиме будь-якій шістнадцятковій цифрі. Якщо - є екранованим (наприклад, [a\-z]) або якщо він розміщений як перший чи останній символ (наприклад [-a] або [a-] ), він відповідатиме літералу '-'.

• Os caracteres especiais, exceto contrabarra, perdem seu significado especial dentro dos conjuntos. Por exemplo, [(+*)] vai corresponder a qualquer um dos caracteres literais '(', '+', '*' ou ')'.

• Backslash either escapes characters which have special meaning in a set such as '-', ']', '^' and '\\' itself or signals a special sequence which represents a single character such as \xa0 or \n or a character class such as \w or \S (defined below). Note that \b represents a single „backspace” character, not a word boundary as outside a set, and numeric escapes such as \1 are always octal escapes, not group references. Special sequences which do not match a single character such as \A and \Z are not allowed.

• Символи, які не входять до діапазону, можуть бути зіставлені шляхом complementing набору. Якщо першим символом набору є '^', усі символи, яких не в наборі, будуть зіставлені. Наприклад, [^5] відповідатиме будь-якому символу, крім '5'', а [^^] відповідатиме будь-якому символу, крім '^'. ^ не має особливого значення, якщо це не перший символ у наборі.

• Чтобы сопоставить литерал ']' внутри набора, поставьте перед ним обратную косую черту или поместите его в начало набора. Например, [()[\]{}] и []()[{}] будут соответствовать правой скобке, а также левой скобке, фигурным и круглым скобкам.

• У майбутньому може бути додано підтримку вкладених наборів і операцій із наборами, як у технічному стандарті Unicode #18. Це призведе до зміни синтаксису, тож для полегшення цієї зміни FutureWarning наразі буде викликано у неоднозначних випадках. Це включає в себе набори, що починаються з літерала '[' або містять літеральні послідовності символів '--', '&&', '~~' і '| |'. Щоб уникнути попередження, екрануйте їх зворотною скісною рискою.

Zmienione w wersji 3.7: FutureWarning викликається, якщо набір символів містить конструкції, які семантично зміняться в майбутньому.

|

A|B, де A і B можуть бути довільними RE, створює регулярний вираз, який відповідатиме A або B. Таким чином довільна кількість RE може бути розділена символом '|'. Це також можна використовувати всередині груп (див. нижче). Під час сканування цільового рядка RE, розділені '|', пробуються зліва направо. Якщо один шаблон повністю збігається, ця гілка приймається. Це означає, що як тільки A збігається, B більше не перевірятиметься, навіть якщо це призведе до довшого загального збігу. Іншими словами, оператор '|'' ніколи не є жадібним. Щоб відповідати літералу '|', використовуйте \| або вкладіть його в клас символів, як у [|].

(...)

Збігається з будь-яким регулярним виразом у дужках і вказує на початок і кінець групи; вміст групи може бути отриманий після того, як було виконано збіг, і може бути зіставлений пізніше в рядку за допомогою спеціальної послідовності \number, описаної нижче. Щоб зіставити літерали '(' або ')', використовуйте \( або \) або вкладіть їх у клас символів: [(] , [)].

(?...)

Це нотація розширення ('?'' після ' ('' не має значення інакше). Перший символ після '?'' визначає значення та подальший синтаксис Розширення зазвичай не створюють нову групу; (?P <name> ...) є єдиним винятком із цього правила. Нижче наведено наразі підтримувані розширення.

(?aiLmsux)

(Одна или несколько букв из набора 'a', 'i', 'L', 'm', s', `` «u», ``'x'.) Группа соответствует пустой строке; буквы устанавливают соответствующие флаги для всего регулярного выражения:

• re.A (соответствие только ASCII)

• re.I (игнорировать регистр)

• re.L (зависит от локали)

• re.M (многострочный)

• re.S (точка соответствует всем)

• re.U (соответствие Юникода)

• re.X (многословный)

(Флаги описаны в Modul-Modul.) Это полезно, если вы хотите включить флаги как часть регулярного выражения вместо передачи аргумента flag в :func: функция re.compile. Флаги следует использовать первыми в строке выражения.

Zmienione w wersji 3.11: Эту конструкцию можно использовать только в начале выражения.

(?:...)

Версія звичайних круглих дужок без захоплення. Збігається з будь-яким регулярним виразом у дужках, але підрядок, який відповідає групі, неможливо отримати після виконання збігу або посилатися на нього пізніше в шаблоні.

(?aiLmsux-imsx:...)

(Ноль или более букв из набора 'a', 'i', 'L', 'm', s', `` «u», ``'x', за которым необязательно следует '-', за которым следует одна или несколько букв из 'i', 'm', `` «s», ``'x'.) Буквы устанавливают или снимают соответствующие флаги для части выражения:

• re.A (соответствие только ASCII)

• re.I (игнорировать регистр)

• re.L (зависит от локали)

• re.M (многострочный)

• re.S (точка соответствует всем)

• re.U (соответствие Юникода)

• re.X (многословный)

(Флаги описаны в Modul-Modul.)

Буквы 'a', 'L' и 'u' являются взаимоисключающими при использовании в качестве встроенных флагов, поэтому их нельзя комбинировать или следовать за '-' . Вместо этого, когда один из них появляется во встроенной группе, он переопределяет режим сопоставления во включающей группе. В шаблонах Юникода (?a:...) переключается на соответствие только ASCII, а (?u:...) переключается на соответствие Юникода (по умолчанию). В байтовых шаблонах (?L:...) переключается на соответствие, зависящее от локали, а (?a:...) переключается на соответствие только ASCII (по умолчанию). Это переопределение действует только для узкой встроенной группы, а исходный режим сопоставления восстанавливается за пределами группы.

Dodane w wersji 3.6.

Zmienione w wersji 3.7: Літери 'a', 'L' і 'u' також можна використовувати в групі.

(?>...)

Пытается сопоставить ..., как если бы это было отдельное регулярное выражение, и в случае успеха продолжает сопоставлять остальную часть следующего за ним шаблона. Если последующий шаблон не соответствует, стек можно развернуть только до точки перед (?>...), потому что после выхода выражение, известное как атомарная группа, выбросил все очки стека внутри себя. Таким образом, (?>.*). никогда не будет соответствовать ничему, потому что сначала .* будет соответствовать всем возможным символам, а затем, когда не останется ничего для сопоставления, последний . не сможет соответствовать. соответствовать. Поскольку в атомарной группе нет сохраненных точек стека, и перед ней нет точки стека, все выражение не будет соответствовать.

Dodane w wersji 3.11.

(?P<name>...)

Аналогично обычным круглым скобкам, но подстрока, соответствующая группе, доступна через символическое имя группы name. Имена групп должны быть допустимыми идентификаторами Python, а в шаблонах bytes они могут содержать только байты в диапазоне ASCII. Каждое имя группы должно быть определено только один раз в регулярном выражении. Символическая группа также является пронумерованной группой, как если бы группа не имела имени.

На іменовані групи можна посилатися в трьох контекстах. Якщо шаблон (?P <quote> ['"]).*?(?P=quote) (тобто відповідає рядку в одинарних або подвійних лапках):

Контекст посилання на групу „цитата”	Способи посилання на нього
за таким самим шаблоном	(?P=quote) (як показано) \1
під час обробки відповідного об’єкта m	m.group('quote') m.end('quote') (etc.)
у рядку, переданому в аргумент repl re.sub()	\g<quote> \g<1> \1

Zmienione w wersji 3.12: В шаблонах bytes группа name может содержать только байты в диапазоне ASCII (b'\x00'-b'\x7f'.

(?P=name)

Зворотне посилання на іменовану групу; він відповідає будь-якому тексту, який відповідав попередній групі під назвою name.

(?#...)

коментар; вміст круглих дужок просто ігнорується.

(?=...)

Збігається, якщо ... збігається наступним, але не споживає жоден рядок. Це називається lookahead assertion. Наприклад, Isaac (?=Azimov) відповідатиме 'Isaac '', лише якщо за ним йде 'Azimov'.

(?!...)

Збігається, якщо ... не збігається наступним. Це негативне випереджальне твердження. Наприклад, Isaac (?!Azimov) відповідатиме 'Isaac '', лише якщо за ним не йде 'Azimov'.

(?<=...)

Збігається, якщо поточній позиції в рядку передує відповідність для ..., яка закінчується на поточній позиції. Це називається позитивним ретроспективним твердженням. (?<=abc)def знайде збіг у 'abcdef', оскільки огляд назад створить резервну копію 3 символів і перевірить, чи збігається шаблон, що міститься. Вміщений шаблон має збігатися лише з рядками певної фіксованої довжини, тобто допустимі abc або a|b, але a* і a{3,4} заборонені . Зауважте, що шаблони, які починаються з позитивних ретроспективних тверджень, не збігатимуться на початку рядка, що шукається; швидше за все, ви захочете використовувати функцію search(), а не функцію match():

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

У цьому прикладі шукається слово після дефіса:

>>> m = re.search(r'(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'

Zmienione w wersji 3.5: Додано підтримку групових посилань фіксованої довжини.

(?<!...)

Збігається, якщо поточній позиції в рядку не передує збіг для .... Це називається negative lookbehind assertion. Подібно до позитивних ретроспективних тверджень, шаблон, що міститься, повинен відповідати лише рядкам певної фіксованої довжини. Шаблони, які починаються з негативних ретроспективних тверджень, можуть збігатися на початку рядка, який шукається.

(?(id/name)yes-pattern|no-pattern)

Спробує знайти відповідність за допомогою yes-pattern, якщо група з заданим id або name існує, і за допомогою no-pattern, якщо вона не існує. no-pattern є необов’язковим і його можна опустити. Наприклад, ( <)?(\w+@\w+(?:\.\w+)+)(?(1)> |$) є поганим шаблоном відповідності електронної пошти, який збігатиметься з '<user@host.com>', а також 'user@host.com', але не з '<user@host.com' nor 'user@host.com> '.

Zmienione w wersji 3.12: Группа id может содержать только цифры ASCII. В шаблонах bytes группа name может содержать только байты в диапазоне ASCII (b'\x00'-b'\x7f'.

Спеціальні послідовності складаються з '\' і символу зі списку нижче. Якщо звичайний символ не є цифрою ASCII або літерою ASCII, тоді результуючий RE відповідатиме другому символу. Наприклад, \$ відповідає символу ''$'.

\number

Відповідає вмісту групи з тим самим номером. Групи нумеруються, починаючи з 1. Наприклад, (.+) \1 відповідає 'the' або '55 55', але не 'thethe' (примітка пробіл після групи). Цю спеціальну послідовність можна використовувати лише для відповідності одній із перших 99 груп. Якщо перша цифра числа дорівнює 0 або число складається з 3 вісімкових цифр, це не буде інтерпретовано як збіг групи, а як символ із вісімковим значенням число. Усередині '[' і ']' класу символів усі цифрові екрановані символи розглядаються як символи.

\A

Збігається лише на початку рядка.

\b

Соответствует пустой строке, но только в начале или конце слова. Слово определяется как последовательность словных символов. Обратите внимание, что формально \b определяется как граница между символами \w и \W (или наоборот) или между \w и началом или конец строки. Это означает, что r'\bat\b' соответствует 'at', 'at.', '(at)' и 'as at ay' `` но не ``'попытка' или атлас'.

Символами слов по умолчанию в шаблонах Юникода (str) являются буквенно-цифровые символы Юникода и знак подчеркивания, но это можно изменить с помощью флага ASCII. Границы слов определяются текущей локалью, если используется флаг LOCALE.

Informacja

Внутри диапазона символов \b представляет собой символ возврата на задний план для совместимости со строковыми литералами Python.

\B

Соответствует пустой строке, но только если она не находится в начале или конце слова. Это означает, что r'at\B' соответствует 'athens', 'atom', 'attorney', но не 'at', `` «at.»`` или 'at!'. \B является противоположностью \b, поэтому символы слов в шаблонах Юникода (str) представляют собой буквенно-цифровые символы Юникода или знак подчеркивания, хотя это можно изменить с помощью LOCALE.

Informacja

Note that \B does not match an empty string, which differs from RE implementations in other programming languages such as Perl. This behavior is kept for compatibility reasons.

\d

Для шаблонів Unicode (str):

Соответствует любой десятичной цифре Юникода (то есть любому символу из категории символов Юникода [Nd]). Сюда входят [0-9], а также многие другие цифровые символы.

Соответствует [0-9], если используется флаг ASCII.

Для 8-бітових (байтових) шаблонів:

Соответствует любой десятичной цифре в наборе символов ASCII; это эквивалентно [0-9].

\D

Соответствует любому символу, кроме десятичной цифры. Это противоположность \d.

Соответствует [^0-9], если используется флаг ASCII.

\s

Для шаблонів Unicode (str):

Соответствует пробельным символам Юникода (как определено в str.isspace()). Сюда входят [ \t\n\r\f\v], а также многие другие символы, например неразрывные пробелы, предусмотренные правилами типографики во многих языках.

Соответствует [ \t\n\r\f\v], если используется флаг ASCII.

Для 8-бітових (байтових) шаблонів:

Відповідає символам, які вважаються пробілами в наборі символів ASCII; це еквівалентно [ \t\n\r\f\v].

\S

Соответствует любому символу, не являющемуся пробелом. Это противоположность \s.

Соответствует [^ \t\n\r\f\v], если используется флаг ASCII.

\w

Для шаблонів Unicode (str):

Соответствует символам слов Юникода; сюда входят все буквенно-цифровые символы Юникода (как определено в str.isalnum()), а также подчеркивание (_).

Соответствует [a-zA-Z0-9_], если используется флаг ASCII.

Для 8-бітових (байтових) шаблонів:

Соответствует символам, которые считаются буквенно-цифровыми в наборе символов ASCII; это эквивалентно [a-zA-Z0-9_]. Если используется флаг LOCALE, он соответствует символам, считающимся буквенно-цифровыми в текущей локали, и знаку подчеркивания.

\W

Соответствует любому символу, который не является символом слова. Это противоположность \w. По умолчанию соответствует символам без подчеркивания (_), для которых str.isalnum() возвращает False.

Соответствует [^a-zA-Z0-9_], если используется флаг ASCII.

Если используется флаг LOCALE, он соответствует символам, которые не являются ни буквенно-цифровыми в текущей локали, ни подчеркиванием.

\Z

Збігається лише в кінці рядка.

Большинство escape-последовательностей, поддерживаемых строковыми литералами Python, также принимаются анализатором регулярных выражений:

\a      \b      \f      \n
\N      \r      \t      \u
\U      \v      \x      \\

(Зауважте, що \b використовується для представлення меж слів і означає „backspace” лише всередині класів символів.)

escape-последовательности '\u', '\U' и '\N' распознаются только в шаблонах Unicode (str). В шаблонах байтов это ошибки. Неизвестные escape-символы ASCII-букв зарезервированы для использования в будущем и рассматриваются как ошибки.

Вісімкові втечі включені в обмеженій формі. Якщо першою цифрою є 0 або є три вісімкові цифри, це вважається вісімковим екрануванням. В іншому випадку це посилання на групу. Що стосується рядкових літералів, вісімкові символи екранування завжди мають не більше трьох цифр.

Zmienione w wersji 3.3: Було додано керуючі послідовності '\u' і '\U'.

Zmienione w wersji 3.6: Невідомі вихідні символи, що складаються з '\' і літери ASCII, тепер є помилками.

Zmienione w wersji 3.8: Добавлена ​​escape-последовательность 'N{name}'. Как и в случае строковых литералов, он расширяется до именованного символа Юникода (например, '\N{EM DASH}').

Modul-Modul

Модуль визначає кілька функцій, констант і виключення. Деякі функції є спрощеними версіями повнофункціональних методів для скомпільованих регулярних виразів. Більшість нетривіальних програм завжди використовують скомпільовану форму.

Прапори

Zmienione w wersji 3.6: Константи прапорів тепер є екземплярами RegexFlag, який є підкласом enum.IntFlag.

class re.RegexFlag

Класс enum.IntFlag, содержащий параметры регулярного выражения, перечисленные ниже.

Dodane w wersji 3.11: - added to __all__

re.A

re.ASCII

Создайте \w, \W, \b, \B, \d, \D, \s и \S выполняет сопоставление только ASCII вместо полного сопоставления Unicode. Это имеет смысл только для шаблонов Unicode (str) и игнорируется для шаблонов байтов.

Соответствует встроенному флагу (?a).

Informacja

Флаг U по-прежнему существует для обратной совместимости, но он является избыточным в Python 3, поскольку по умолчанию для шаблонов str соответствует Unicode, а для шаблонов байтов соответствие Unicode не разрешено. UNICODE и встроенный флаг (?u) также избыточны.

re.DEBUG

Отображение отладочной информации о скомпилированном выражении.

Нет соответствующего встроенного флага.

re.I

re.IGNORECASE

Выполнить сопоставление без учета регистра; выражения типа [AZ] также будут соответствовать строчным буквам. Полное соответствие Юникода (например, сопоставление Ü ü) также работает, если только не используется флаг ASCII для отключения совпадений, отличных от ASCII. Текущая локаль не меняет эффект этого флага, если также не используется флаг LOCALE.

Соответствует встроенному флагу (?i).

Обратите внимание, что когда шаблоны Unicode [az] или [AZ] используются в сочетании с флагом IGNORECASE, они будут соответствовать 52 буквам ASCII и 4 дополнительным буквам, отличным от ASCII: «İ» (U+0130, латинская заглавная буква I с точкой вверху), «ı» (U+0131, латинская строчная буква без точки i), «ſ» (U+017F, длинная латинская строчная буква s) и «K» (U+212A, знак Кельвина). Если используется флаг ASCII, сопоставляются только буквы от «a» до «z» и от «A» до «Z».

re.L

re.LOCALE

Сделать \w, \W, \b, \B и соответствие без учета регистра в зависимости от текущей локали. Этот флаг можно использовать только с шаблонами байтов.

Corresponds to the inline flag (?L).

Ostrzeżenie

Этот флаг не рекомендуется; вместо этого рассмотрите сопоставление Unicode. Механизм локалей очень ненадежен, поскольку он обрабатывает только одну «культуру» за раз и работает только с 8-битными локалями. Сопоставление Юникода включено по умолчанию для шаблонов Юникода (str) и может обрабатывать различные локали и языки.

Zmienione w wersji 3.6: LOCALE может использоваться только с байтовыми шаблонами и несовместим с ASCII.

Zmienione w wersji 3.7: Скомпилированные объекты регулярных выражений с флагом LOCALE больше не зависят от локали во время компиляции. На результат сопоставления влияет только локаль во время сопоставления.

re.M

re.MULTILINE

Если он указан, символ шаблона '^' совпадает в начале строки и в начале каждой строки (сразу после каждой новой строки); и символ шаблона '$' совпадает в конце строки и в конце каждой строки (непосредственно перед каждой новой строкой). По умолчанию '^' соответствует только началу строки, а '$' только в конце строки и непосредственно перед символом новой строки (если таковой имеется) в конце строки.

Соответствует встроенному флагу (?m).

re.NOFLAG

Указывает, что флаг не применяется, значение равно «0». Этот флаг можно использовать в качестве значения по умолчанию для аргумента ключевого слова функции или в качестве базового значения, которое будет объединяться по условному оператору ИЛИ с другими флагами. Пример использования в качестве значения по умолчанию:

def myfunc(text, flag=re.NOFLAG):
    return re.match(text, flag)

Dodane w wersji 3.11.

re.S

re.DOTALL

Сделайте так, чтобы специальный символ '.' соответствовал любому символу, включая новую строку; без этого флага '.' будет соответствовать всему, кроме новой строки.

Соответствует встроенному флагу (?s).

re.U

re.UNICODE

В Python 3 символы Юникода по умолчанию сопоставляются с шаблонами str. Поэтому этот флаг является избыточным и не влияет и сохраняется только для обратной совместимости.

См. ASCII, чтобы вместо этого ограничить соответствие символами ASCII.

re.X

re.VERBOSE

Этот флаг позволяет вам писать регулярные выражения, которые выглядят лучше и более читабельны, позволяя визуально разделять логические разделы шаблона и добавлять комментарии. Пробелы внутри шаблона игнорируются, за исключением случаев, когда они находятся в классе символов, или когда им предшествует неэкранированная обратная косая черта, или внутри токенов, таких как *?, (?: или (?P<... > Например, (? : и * ? не допускаются. Если строка содержит символ #, который не принадлежит классу символов и которому не предшествует неэкранированная обратная косая черта. , все символы начиная с самого левого, например #, до конца строки игнорируются.

Це означає, що два наступних об’єкти регулярного виразу, які відповідають десятковому числу, функціонально однакові:

a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

Відповідає вбудованому прапору (?x).

Zadania

re.compile(pattern, flags=0)

Скомпілюйте шаблон регулярного виразу в об’єкт регулярного виразу, який можна використовувати для зіставлення за допомогою його match(), search() та інших методів, описаних нижче .

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Послідовність

prog = re.compile(pattern)
result = prog.match(string)

setara dengan:

result = re.match(pattern, string)

але використання re.compile() і збереження отриманого об’єкта регулярного виразу для повторного використання ефективніше, якщо вираз використовуватиметься кілька разів в одній програмі.

Informacja

Зібрані версії найновіших шаблонів, переданих до re.compile(), і функції відповідності на рівні модуля кешуються, тому програмам, які використовують лише кілька регулярних виразів одночасно, не потрібно турбуватися про компіляцію регулярних виразів.

re.search(pattern, string, flags=0)

Просканируйте строку в поисках первого места, где регулярное выражение шаблон создает совпадение, и верните соответствующий Match. Верните None, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от поиска совпадения нулевой длины в какой-то точке строки.

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

re.match(pattern, string, flags=0)

Если ноль или более символов в начале строки соответствуют регулярному выражению шаблон, верните соответствующий Match. Верните None, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Зауважте, що навіть у режимі MULTILINE re.match() збігатиметься лише на початку рядка, а не на початку кожного рядка.

Якщо ви хочете знайти збіг будь-де в string, використовуйте натомість search() (див. також search() проти match()).

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

re.fullmatch(pattern, string, flags=0)

Если вся строка соответствует шаблону регулярного выражения, верните соответствующий Match. Верните None, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Dodane w wersji 3.4.

re.split(pattern, string, maxsplit=0, flags=0)

Розділіть рядок на входження шаблону. Якщо в шаблоні використовуються дужки для захоплення, тоді текст усіх груп у шаблоні також повертається як частина результуючого списку. Якщо maxsplit відмінний від нуля, відбувається не більше ніж maxsplit, а залишок рядка повертається як останній елемент списку.

>>> re.split(r'\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'\W+', 'Words, words, words.', maxsplit=1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

Якщо в розділювачі є групи захоплення, і він збігається на початку рядка, результат розпочнеться з порожнього рядка. Те саме стосується кінця рядка:

>>> re.split(r'(\W+)', '...words, words...')
['', '...', 'words', ', ', 'words', '...', '']

Таким чином, компоненти роздільників завжди знаходяться за однаковими відносними індексами в списку результатів.

Correspondências vazias adjacentes não são possíveis, mas uma correspondência vazia pode ocorrer imediatamente após uma correspondência não-vazia.

>>> re.split(r'\b', 'Words, words, words.')
['', 'Words', ', ', 'words', ', ', 'words', '.']
>>> re.split(r'\W*', '...words...')
['', '', 'w', 'o', 'r', 'd', 's', '', '']
>>> re.split(r'(\W*)', '...words...')
['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Zmienione w wersji 3.1: Додано необов’язковий аргумент flags.

Zmienione w wersji 3.7: Додано підтримку розбиття на шаблон, який може відповідати порожньому рядку.

Niezalecane od wersji 3.13: Передача maxsplit и flags в качестве позиционных аргументов устарела. В будущих версиях Python это будут параметры только для ключевых слов.

re.findall(pattern, string, flags=0)

Повертає всі неперекриваючі збіги шаблону в рядку у вигляді списку рядків або кортежів. Рядок сканується зліва направо, і збіги повертаються в порядку знайдення. Порожні збіги включаються в результат.

Результат залежить від кількості груп захоплення в шаблоні. Якщо груп немає, поверніть список рядків, які відповідають повному шаблону. Якщо існує рівно одна група, поверніть список рядків, які відповідають цій групі. Якщо присутні кілька груп, поверніть список кортежів рядків, які відповідають групам. Незахоплюючі групи не впливають на форму результату.

>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
[('width', '20'), ('height', '10')]

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Zmienione w wersji 3.7: Непорожні збіги тепер можуть починатися одразу після попереднього порожнього збігу.

re.finditer(pattern, string, flags=0)

Возвращает iterator, возвращающий Match объекты по всем непересекающимся совпадениям для pattern RE в string. Строка сканируется слева направо, и совпадения возвращаются в найденном порядке. Пустые совпадения включаются в результат.

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Zmienione w wersji 3.7: Непорожні збіги тепер можуть починатися одразу після попереднього порожнього збігу.

re.sub(pattern, repl, string, count=0, flags=0)

Повертає рядок, отриманий шляхом заміни крайніх лівих неперекриваючих входжень pattern у string на заміну repl. Якщо шаблон не знайдено, рядок повертається без змін. repl може бути рядком або функцією; якщо це рядок, будь-які вихідні символи зворотної косої риски в ньому обробляються. Тобто \n перетворюється на один символ нового рядка, \r перетворюється на повернення каретки і так далі. Невідомі вихідні коди літер ASCII зарезервовано для майбутнього використання та розглядаються як помилки. Інші невідомі вихідні сигнали, такі як \& залишаються в спокої. Зворотні посилання, такі як \6, замінюються підрядком, який відповідає групі 6 у шаблоні. Наприклад:

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',
...        r'static PyObject*\npy_\1(void)\n{',
...        'def myfunc():')
'static PyObject*\npy_myfunc(void)\n{'

Если repl — функция, она вызывается для каждого непересекающегося вхождения pattern. Функция принимает один аргумент Match и возвращает строку замены. Например:

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
...
>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
'pro--gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam'

Шаблон может быть строкой или Pattern.

O argumento opcional count é o número máximo de ocorrências do padrão a ser substituído; count deve ser um número inteiro não negativo. Se omitido ou igual a zero, todas as ocorrências serão substituídas.

Correspondências vazias adjacentes não são possíveis, mas uma correspondência vazia pode ocorrer imediatamente após uma correspondência não-vazia. Como resultado, sub('x*', '-', 'abxd') retorna '-a-b--d-' invés de '-a-b-d-'.

В аргументах рядкового типу repl, на додаток до екранованих символів і зворотних посилань, описаних вище, \g <name> використовуватиме підрядок, який відповідає групі з назвою name, як визначено (? P <name> ...) синтаксис. \g <number> використовує відповідний номер групи; \g <2>, отже, еквівалентний \2, але не є неоднозначним у заміні, такій як \g <2> 0. \20 інтерпретуватиметься як посилання на групу 20, а не як посилання на групу 2, за якою йде літеральний символ '0'. Зворотне посилання \g <0> замінює весь підрядок, який відповідає RE.

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

Zmienione w wersji 3.1: Додано необов’язковий аргумент flags.

Zmienione w wersji 3.5: Невідповідні групи замінюються порожнім рядком.

Zmienione w wersji 3.6: Невідомі вихідні коди в шаблоні, що складаються з '\' і літери ASCII, тепер є помилками.

Zmienione w wersji 3.7: Escapes desconhecidos em repl consistindo em '\' e uma letra ASCII agora são erros. Uma correspondência vazia pode ocorrer imediatamente após uma correspondência não-vazia.

Zmienione w wersji 3.12: Группа id может содержать только цифры ASCII. В строках замены bytes группа name может содержать только байты в диапазоне ASCII (b'\x00'-b'\x7f'.

Niezalecane od wersji 3.13: Передача count и flags в качестве позиционных аргументов устарела. В будущих версиях Python это будут параметры только для ключевых слов.

re.subn(pattern, repl, string, count=0, flags=0)

Виконайте ту саму операцію, що й sub(), але поверніть кортеж (new_string, number_of_subs_made).

Поведение выражения можно изменить, указав значение flags. Значениями могут быть любые переменные flags, объединенные с помощью побитового ИЛИ (оператор |).

re.escape(pattern)

Екранування спеціальних символів у шаблоні. Це корисно, якщо ви хочете зіставити довільний рядок літералу, який може містити метасимволи регулярного виразу. Наприклад:

>>> print(re.escape('https://www.python.org'))
https://www\.python\.org

>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+

>>> operators = ['+', '-', '*', '/', '**']
>>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
/|\-|\+|\*\*|\*

Цю функцію не можна використовувати для рядка заміни в sub() і subn(), слід екранувати лише зворотні косі риски. Наприклад:

>>> digits_re = r'\d+'
>>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
>>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
/usr/sbin/sendmail - \d+ errors, \d+ warnings

Zmienione w wersji 3.3: Символ „_” більше не екранується.

Zmienione w wersji 3.7: Екрануються лише символи, які можуть мати спеціальне значення в регулярному виразі. У результаті '!', '"', '%', "'", ',', '/', ':', ';', '<', '=', '>', '@', і "`" більше не екрануються.

re.purge()

Очистити кеш регулярних виразів.

Wyjątki

exception re.PatternError(msg, pattern=None, pos=None)

Исключение возникает, когда строка, переданная одной из функций, не является допустимым регулярным выражением (например, она может содержать несовпадающие круглые скобки) или когда во время компиляции или сопоставления возникает какая-либо другая ошибка. Если строка не содержит совпадений с шаблоном, это никогда не является ошибкой. Экземпляр PatternError имеет следующие дополнительные атрибуты:

msg

Неформатне повідомлення про помилку.

pattern

Шаблон регулярного виразу.

pos

Індекс у шаблоні, де не вдалося компілювати (може бути None).

lineno

Рядок, що відповідає pos (може бути None).

colno

Стовпець, що відповідає pos (може бути None).

Zmienione w wersji 3.5: Додані додаткові атрибути.

Zmienione w wersji 3.13: «PatternError» изначально назывался «error»; последний сохраняется как псевдоним для обратной совместимости.

Об’єкти регулярного виразу

class re.Pattern

Скомпилированный объект регулярного выражения, возвращаемый re.compile().

Zmienione w wersji 3.9: re.Pattern поддерживает [] для указания шаблона Unicode (str) или байтов. См. Genel Takma Ad Türü.

Pattern.search(string[, pos[, endpos]])

Просканируйте строку в поисках первого места, где это регулярное выражение создает совпадение, и верните соответствующий Match. Верните None, если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от поиска совпадения нулевой длины в какой-то точке строки.

Необов’язковий другий параметр pos дає індекс у рядку, з якого має початися пошук; за замовчуванням 0. Це не зовсім еквівалентно нарізанню струни; символ шаблону '^' збігається на справжньому початку рядка та в позиціях одразу після нового рядка, але не обов’язково в індексі, з якого має початися пошук.

Необов’язковий параметр endpos обмежує, наскільки далеко буде здійснюватися пошук рядка; це буде так, ніби рядок складається з endpos символів, тому шукатимуть збіги лише за символами від pos до endpos - 1. Якщо endpos менше ніж pos, збіг не знайдено; інакше, якщо rx є скомпільованим об’єктом регулярного виразу, rx.search(string, 0, 50) еквівалентно rx.search(string[:50], 0).

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

Pattern.match(string[, pos[, endpos]])

Если ноль или более символов в начале строки соответствуют этому регулярному выражению, верните соответствующий Match. Верните None, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Необов’язкові параметри pos і endpos мають те саме значення, що й для методу search().

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>

Якщо ви хочете знайти збіг будь-де в string, використовуйте натомість search() (див. також search() проти match()).

Pattern.fullmatch(string[, pos[, endpos]])

Если вся строка соответствует этому регулярному выражению, верните соответствующий Match. Верните None, если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.

Необов’язкові параметри pos і endpos мають те саме значення, що й для методу search().

>>> шаблон = re.compile("o[gh]")
>>> Pattern.fullmatch("dog") # Нет совпадений, так как "o" не находится в начале слова "dog".
>>> шаблон.fullmatch("ogre") # Нет совпадений, поскольку не совпадает вся строка.
>>> шаблон.fullmatch("собачка", 1, 3) # Соответствует в заданных пределах. <re.Match объект; span=(1, 3), match='og'>

Dodane w wersji 3.4.

Pattern.split(string, maxsplit=0)

Ідентична функції split(), використовуючи скомпільований шаблон.

Pattern.findall(string[, pos[, endpos]])

Подібно до функції findall(), використовує скомпільований шаблон, але також приймає додаткові параметри pos і endpos, які обмежують область пошуку, як для search().

Pattern.finditer(string[, pos[, endpos]])

Подібно до функції finditer(), яка використовує скомпільований шаблон, але також приймає додаткові параметри pos і endpos, які обмежують область пошуку, як для search().

Pattern.sub(repl, string, count=0)

Ідентична функції sub(), використовуючи скомпільований шаблон.

Pattern.subn(repl, string, count=0)

Ідентична функції subn(), використовуючи скомпільований шаблон.

Pattern.flags

Флаги соответствия регулярных выражений. Это комбинация флагов, заданных для compile(), любых встроенных флагов (?...) в шаблоне и неявных флагов, таких как UNICODE если шаблон представляет собой строку Юникода.

Pattern.groups

Кількість груп захоплення в шаблоні.

Pattern.groupindex

Словник, що відображає будь-які символічні назви груп, визначені (?P <id> ), на номери груп. Словник порожній, якщо в шаблоні не використовувалися символічні групи.

Pattern.pattern

Рядок шаблону, з якого було скомпільовано об’єкт шаблону.

Zmienione w wersji 3.7: Додано підтримку copy.copy() і copy.deepcopy(). Зкомпільовані об’єкти регулярного виразу вважаються атомарними.

Зіставте об’єкти

Об’єкти відповідності завжди мають логічне значення True. Оскільки match() і search() повертають None за відсутності збігу, ви можете перевірити, чи був збіг за допомогою простого оператора if: :

match = re.search(pattern, string)
if match:
    process(match)

class re.Match

Объект соответствия, возвращаемый успешными запросами matchи searches.

Zmienione w wersji 3.9: re.Match поддерживает [] для указания соответствия Юникода (str) или байтов. См. Genel Takma Ad Türü.

Match.expand(template)

Верните строку, полученную путем замены обратной косой черты в строке шаблона template, как это делается с помощью метода sub(). Экранирующие символы, такие как \n, преобразуются в соответствующие символы, а также числовые обратные ссылки (\1, \2) и именованные обратные ссылки (\g<1>, `` g<name>``) заменяются содержимым соответствующей группы. Обратная ссылка \g<0> будет заменена полным совпадением.

Zmienione w wersji 3.5: Невідповідні групи замінюються порожнім рядком.

Match.group([group1, ...])

Повертає одну або кілька підгруп збігу. Якщо є один аргумент, результатом буде один рядок; якщо є кілька аргументів, результатом є кортеж з одним елементом на аргумент. Без аргументів group1 за замовчуванням дорівнює нулю (повертається весь збіг). Якщо аргумент groupN дорівнює нулю, відповідним значенням, що повертається, є весь відповідний рядок; якщо він знаходиться у включному діапазоні [1..99], це рядок, що відповідає відповідній групі в дужках. Якщо номер групи є від’ємним або перевищує кількість груп, визначених у шаблоні, виникає виняток IndexError. Якщо група міститься в частині шаблону, яка не відповідає, відповідним результатом є None. Якщо група міститься в частині шаблону, яка збігалася кілька разів, повертається останній збіг.

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)       # The entire match
'Isaac Newton'
>>> m.group(1)       # The first parenthesized subgroup.
'Isaac'
>>> m.group(2)       # The second parenthesized subgroup.
'Newton'
>>> m.group(1, 2)    # Multiple arguments give us a tuple.
('Isaac', 'Newton')

Якщо регулярний вираз використовує синтаксис (?P <name> ...), аргументи groupN також можуть бути рядками, що ідентифікують групи за назвою групи. Якщо рядковий аргумент не використовується як ім’я групи в шаблоні, виникає виняток IndexError.

Помірно складний приклад:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'

Іменовані групи також можна посилатися за їх індексом:

>>> m.group(1)
'Malcolm'
>>> m.group(2)
'Reynolds'

Якщо група збігається кілька разів, доступним буде лише останній збіг:

>>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
>>> m.group(1)                        # Returns only the last match.
'c3'

Match.__getitem__(g)

Це ідентично m.group(g). Це дозволяє легше отримати доступ до окремої групи з матчу:

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m[0]       # The entire match
'Isaac Newton'
>>> m[1]       # The first parenthesized subgroup.
'Isaac'
>>> m[2]       # The second parenthesized subgroup.
'Newton'

Также поддерживаются именованные группы:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Isaac Newton")
>>> m['first_name']
'Isaac'
>>> m['last_name']
'Newton'

Dodane w wersji 3.6.

Match.groups(default=None)

Повертає кортеж, що містить усі підгрупи відповідності, від 1 до будь-якої кількості груп у шаблоні. Аргумент default використовується для груп, які не брали участі в матчі; за замовчуванням None.

Dla przykładu:

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')

Якщо ми зробимо знак після коми необов’язковим, не всі групи можуть брати участь у матчі. Для цих груп за замовчуванням буде None, якщо не вказано аргумент default:

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups()      # Second group defaults to None.
('24', None)
>>> m.groups('0')   # Now, the second group defaults to '0'.
('24', '0')

Match.groupdict(default=None)

Повертає словник, що містить усі іменовані підгрупи збігу, ключ яких містить назву підгрупи. Аргумент default використовується для груп, які не брали участі в матчі; за замовчуванням None. Наприклад:

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

Match.start([group])

Match.end([group])

Повертає індекси початку та кінця підрядка, які відповідають групі; group за замовчуванням дорівнює нулю (це означає весь відповідний підрядок). Повертає -1, якщо група існує, але не брала участі в матчі. Для об’єкта збігу m і групи g, яка внесла свій внесок у збіг, підрядок, який відповідає групі g (еквівалент m.group(g)) є

m.string[m.start(g):m.end(g)]

Зауважте, що m.start(group) дорівнюватиме m.end(group), якщо group відповідає нульовому рядку. Наприклад, після m = re.search('b(c?)', 'cba'), m.start(0) дорівнює 1, m.end(0) дорівнює 2, m.start(1) і m.end(1) мають значення 2, а m.start(2) викликає виняток IndexError.

Приклад видалення remove_this з електронних адрес:

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'

Match.span([group])

Для збігу m поверніть 2-кортеж (m.start(group), m.end(group)). Зауважте, що якщо група не брала участі в матчі, це (-1, -1). група за замовчуванням дорівнює нулю, весь збіг.

Match.pos

Значення pos, яке було передано в метод search() або match() об’єкта regex. Це індекс у рядку, за яким механізм RE почав шукати збіг.

Match.endpos

Значення endpos, яке було передано в метод search() або match() об’єкта regex. Це індекс у рядку, за який механізм RE не виходить.

Match.lastindex

Цілочисельний індекс останньої відповідної групи захоплення або None, якщо жодна група не була знайдена взагалі. Наприклад, вирази (a)b, ((a)(b)) і ((ab)) матимуть lastindex == 1, якщо застосувати до рядок 'ab'', тоді як вираз (a)(b) матиме lastindex == 2, якщо застосувати до того самого рядка.

Match.lastgroup

Ім’я останньої відповідної групи захоплення або None, якщо група не мала назви, або якщо жодна група не була знайдена взагалі.

Match.re

Об’єкт регулярного виразу, чий метод match() або search() створив цей екземпляр відповідності.

Match.string

Рядок передається до match() або search().

Zmienione w wersji 3.7: Додано підтримку copy.copy() і copy.deepcopy(). Об’єкти відповідності вважаються атомарними.

Приклади регулярних виразів

Перевірка на пару

У цьому прикладі ми використаємо наступну допоміжну функцію, щоб відобразити об’єкти відповідності трохи витонченіше:

def displaymatch(match):
    if match is None:
        return None
    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

Припустімо, що ви пишете покерну програму, де рука гравця представлена у вигляді рядка з 5 символів, де кожен символ представляє карту, „a” — туз, „k” — король, „q” — дама, „j” — валет, „t” означає 10 і „2” - „9”, що представляють картку з таким значенням.

Щоб перевірити, чи даний рядок є правильною рукою, можна зробити наступне:

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
>>> displaymatch(valid.match("akt5q"))  # Valid.
"<Match: 'akt5q', groups=()>"
>>> displaymatch(valid.match("akt5e"))  # Invalid.
>>> displaymatch(valid.match("akt"))    # Invalid.
>>> displaymatch(valid.match("727ak"))  # Valid.
"<Match: '727ak', groups=()>"

Ця остання роздача, "727ak", містила пару або дві карти однакового значення. Щоб зіставити це з регулярним виразом, можна використовувати зворотні посилання як такі:

>>> pair = re.compile(r".*(.).*\1")
>>> displaymatch(pair.match("717ak"))     # Pair of 7s.
"<Match: '717', groups=('7',)>"
>>> displaymatch(pair.match("718ak"))     # No pairs.
>>> displaymatch(pair.match("354aa"))     # Pair of aces.
"<Match: '354aa', groups=('a',)>"

Щоб дізнатися, з якої карти складається пара, можна використати метод group() об’єкта відповідності таким чином:

>>> pair = re.compile(r".*(.).*\1")
>>> pair.match("717ak").group(1)
'7'

# Error because re.match() returns None, which doesn't have a group() method:
>>> pair.match("718ak").group(1)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    re.match(r".*(.).*\1", "718ak").group(1)
AttributeError: 'NoneType' object has no attribute 'group'

>>> pair.match("354aa").group(1)
'a'

Імітація scanf()

Python в настоящее время не имеет эквивалента scanf(). Регулярные выражения, как правило, более мощны, но и более многословны, чем строки формата scanf(). В таблице ниже представлены некоторые более или менее эквивалентные сопоставления между токенами формата scanf() и регулярными выражениями.

scanf() Token	Ekspresi Reguler
%c	.
%5c	.{5}
%d	[-+]?\d+
%e, %E, %f, %g	[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?
%i	[-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+)
%o	[-+]?[0-7]+
%s	\S+
%u	\d+
%x, %X	[-+]?(0[xX])?[\dA-Fa-f]+

Щоб витягти назву файлу та номери з рядка на зразок

/usr/sbin/sendmail - 0 errors, 4 warnings

вы бы использовали формат scanf(), например::

%s - %d errors, %d warnings

Еквівалентним регулярним виразом буде:

(\S+) - (\d+) ошибки, (\d+) предупреждения

search() проти match()

Python предлагает различные примитивные операции, основанные на регулярных выражениях:

• re.match() проверяет совпадение только в начале строки

• re.search() проверяет совпадение в любом месте строки (это то, что Perl делает по умолчанию)

• re.fullmatch() проверяет совпадение всей строки

Dla przykładu:

>>> re.match("c", "abcdef")    # No match
>>> re.search("c", "abcdef")   # Match
<re.Match object; span=(2, 3), match='c'>
>>> re.fullmatch("p.*n", "python") # Match
<re.Match object; span=(0, 6), match='python'>
>>> re.fullmatch("r.*n", "python") # No match

Регулярні вирази, що починаються з '^', можна використовувати з search(), щоб обмежити збіг на початку рядка:

>>> re.match("c", "abcdef")    # No match
>>> re.search("^c", "abcdef")  # No match
>>> re.search("^a", "abcdef")  # Match
<re.Match object; span=(0, 1), match='a'>

Однак зауважте, що в режимі MULTILINE match() збігається лише на початку рядка, тоді як використання search() із регулярним виразом, що починається з '^' збігається на початок кожного рядка.

>>> re.match("X", "A\nB\nX", re.MULTILINE)  # No match
>>> re.search("^X", "A\nB\nX", re.MULTILINE)  # Match
<re.Match object; span=(4, 5), match='X'>

Створення телефонної книги

split() розбиває рядок на список, розділений переданим шаблоном. Цей метод є безцінним для перетворення текстових даних у структури даних, які можна легко читати та змінювати Python, як показано в наступному прикладі створення телефонної книги.

По-перше, ось вхідні дані. Зазвичай він може надходити з файлу, тут ми використовуємо синтаксис рядка в потрійних лапках

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street
...
... Ronald Heathmore: 892.345.3428 436 Finley Avenue
... Frank Burger: 925.541.7625 662 South Dogwood Way
...
...
... Heather Albrecht: 548.326.4584 919 Park Place"""

Записи розділені одним або кількома символами нового рядка. Тепер ми перетворюємо рядок на список, у якому кожен непорожній рядок має окремий запис:

>>> entries = re.split("\n+", text)
>>> entries
['Ross McFluff: 834.345.1254 155 Elm Street',
'Ronald Heathmore: 892.345.3428 436 Finley Avenue',
'Frank Burger: 925.541.7625 662 South Dogwood Way',
'Heather Albrecht: 548.326.4584 919 Park Place']

Нарешті, розділіть кожен запис на список із іменем, прізвищем, номером телефону та адресою. Ми використовуємо параметр maxsplit split(), тому що в адресі є пробіли, наш шаблон поділу:

>>> [re.split(":? ", entry, maxsplit=3) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

Шаблон :? відповідає двокрапці після прізвища, щоб він не зустрічався в списку результатів. За допомогою maxsplit 4 ми можемо відокремити номер будинку від назви вулиці:

>>> [re.split(":? ", entry, maxsplit=4) for entry in entries]
[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],
['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],
['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],
['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

Перебирання тексту

sub() замінює кожне входження шаблону рядком або результатом функції. У цьому прикладі демонструється використання sub() із функцією для „переміщення” тексту або випадкового порядку всіх символів у кожному слові речення, за винятком першого та останнього символів:

>>> def repl(m):
...     inner_word = list(m.group(2))
...     random.shuffle(inner_word)
...     return m.group(1) + "".join(inner_word) + m.group(3)
...
>>> text = "Professor Abdolmalek, please report your absences promptly."
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'
>>> re.sub(r"(\w)(\w+)(\w)", repl, text)
'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

Знайти всі прислівники

findall() відповідає всім входженням шаблону, а не лише першому, як це робить search(). Наприклад, якщо автор хоче знайти всі прислівники в якомусь тексті, він може використати findall() у такий спосіб:

>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly\b", text)
['carefully', 'quickly']

Знайти всі прислівники та їх позиції

Если вам нужна дополнительная информация обо всех совпадениях шаблона, а не о совпавшем тексте, полезно использовать finditer(), поскольку он предоставляет объекты Match вместо строк. Продолжая предыдущий пример, если бы автор хотел найти все наречия и их позиции в каком-то тексте, он бы использовал finditer() следующим образом:

>>> text = "He was carefully disguised but captured quickly by police."
>>> for m in re.finditer(r"\w+ly\b", text):
...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: carefully
40-47: quickly

Необроблена рядкова нотація

Необроблена нотація рядка (r"текст") зберігає регулярні вирази нормальними. Без нього кожен зворотний слеш ('\') у регулярному виразі повинен був би мати префікс іншим, щоб уникнути його. Наприклад, два наступних рядки коду функціонально ідентичні:

>>> re.match(r"\W(.)\1\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>
>>> re.match("\\W(.)\\1\\W", " ff ")
<re.Match object; span=(0, 4), match=' ff '>

Якщо потрібно зіставити літеральний зворотний слеш, його потрібно екранувати у регулярному виразі. У необробленому рядковому записі це означає r"\\". Без нотації необробленого рядка потрібно використовувати "\\\\", роблячи наступні рядки коду функціонально ідентичними:

>>> re.match(r"\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>
>>> re.match("\\\\", r"\\")
<re.Match object; span=(0, 1), match='\\'>

Написання токенізера

Токенизатор або сканер аналізує рядок, щоб класифікувати групи символів. Це корисний перший крок у написанні компілятора чи інтерпретатора.

Текстові категорії вказуються регулярними виразами. Техніка полягає в тому, щоб об’єднати їх у єдиний основний регулярний вираз і виконати цикл послідовних збігів:

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('ASSIGN',   r':='),           # Assignment operator
        ('END',      r';'),            # Statement terminator
        ('ID',       r'[A-Za-z]+'),    # Identifiers
        ('OP',       r'[+\-*/]'),      # Arithmetic operators
        ('NEWLINE',  r'\n'),           # Line endings
        ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
        ('MISMATCH', r'.'),            # Any other character
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

Токенізатор видає такий вихід:

Token(type='IF', value='IF', line=2, column=4)
Token(type='ID', value='quantity', line=2, column=7)
Token(type='THEN', value='THEN', line=2, column=16)
Token(type='ID', value='total', line=3, column=8)
Token(type='ASSIGN', value=':=', line=3, column=14)
Token(type='ID', value='total', line=3, column=17)
Token(type='OP', value='+', line=3, column=23)
Token(type='ID', value='price', line=3, column=25)
Token(type='OP', value='*', line=3, column=31)
Token(type='ID', value='quantity', line=3, column=33)
Token(type='END', value=';', line=3, column=41)
Token(type='ID', value='tax', line=4, column=8)
Token(type='ASSIGN', value=':=', line=4, column=12)
Token(type='ID', value='price', line=4, column=15)
Token(type='OP', value='*', line=4, column=21)
Token(type='NUMBER', value=0.05, line=4, column=23)
Token(type='END', value=';', line=4, column=27)
Token(type='ENDIF', value='ENDIF', line=5, column=4)
Token(type='END', value=';', line=5, column=9)

[Frie09]

Фрідл, Джеффрі. Освоєння регулярних виразів. 3rd ed., O’Reilly Media, 2009. Третє видання книги більше не охоплює Python взагалі, але перше видання охоплювало написання хороших шаблонів регулярних виразів дуже детально.