Регулярные выражения в python от простого к сложному. подробности, примеры, картинки, упражнения

Введение в регулярные выражения

Регулярные выражения, также называемые regex, используются практически во всех языках программирования. В python они реализованы в стандартном модуле . Он широко используется в естественной обработке языка, веб-приложениях, требующих проверки ввода текста (например, адреса электронной почты) и почти во всех проектах в области анализа данных, которые включают в себя интеллектуальную обработку текста.

Эта статья разделена на 2 части.

Прежде чем перейти к синтаксису регулярных выражений, для начала вам лучше понять, как работает модуль .

Итак, сначала вы познакомитесь с 5 основными функциями модуля , а затем посмотрите, как создавать регулярные выражения в python. Узнаете, как построить практически любой текстовый шаблон, который вам, скорее всего, понадобится при работе над проектами, связанными с поиском текста.

Введение

Регулярные выражения используются для сжатого описания некоторого
множества строк с помощью шаблонов, без необходимости перечисления
всех элементов этого множества или явного написания функции для проверки.
Большинство символов соответствуют сами себе («a» соответствует «a» и т. д.).
Исключения из этого правила называются метасимволами: .

Термин «Регулярные выражения» является переводом с английского словосочетания «Regular expressions».
Перевод не очень точно отражает смысл, правильнее было бы «шаблонные выражения».
Регулярное выражение, или коротко «регулярка», состоит из обычных символов и специальных командных последовательностей.
Например, задаёт любую цифру, а — задает любую последовательность из одной или более цифр.

Работа с регулярками реализована во всех современных языках программирования.
Однако существует несколько «диалектов», поэтому функционал регулярных выражений может различаться от языка к языку.
В некоторых языках программирования регулярками пользоваться очень удобно (например, в питоне), в некоторых — не слишком (например, в C++).

Примеры регулярных выражений

Сила и ответственность

Регулярные выражения, или коротко, регулярки — это очень мощный инструмент.
Но использовать их следует с умом и осторожностью, и только там, где они действительно приносят пользу, а не вред.
Во-первых, плохо написанные регулярные выражения работают медленно.
Во-вторых, их зачастую очень сложно читать, особенно если регулярка написана не лично тобой пять минут назад.
В-третьих, очень часто даже небольшое изменение задачи (того, что требуется найти) приводит к значительному изменению выражения.
Поэтому про регулярки часто говорят, что это write only code (код, который только пишут с нуля, но не читают и не правят).
А также шутят: Некоторые люди, когда сталкиваются с проблемой, думают «Я знаю, я решу её с помощью регулярных выражений.» Теперь у них две проблемы.

Формирование регулярного выражения

Регулярное выражение можно сформировать, используя сочетание метасимволов, специальных последовательностей и наборов.

Метасимволы

Метасимвол – это символ с указанным значением.

Особые последовательности

Специальные последовательности – это последовательности, которые содержат (либо за которыми следует) один из символов.

Наборы

Набор – это группа символов, заключенная в квадратные скобки. Он представляет особый смысл.

Три типа машин регулярных выражений

На практике применяются три типа машин регулярных выражений.

1. DFA (Deterministic Finite-state Automaton – детерминированные конечные автоматы) машины работают линейно по времени, поскольку не нуждаются в откатах (и никогда не проверяют один символ дважды). Они могут гарантированно найти самую длинную строку из возможных. Однако, поскольку DFA содержит только конечное состояние, он не может найти образец с обратной ссылкой и, из-за отсутствия конструкций с явным расширением, не ловит подвыражений. Они используются, например, в awk, egrep или lex.
2. Традиционные NFA-машины (NonDeterministic Finite-state Automaton – недетерминированные конечные автоматы) используют «жадный» алгоритм отката, проверяя все возможные расширения регулярного выражения в определенном порядке и выбирая первое подходящее значение. Поскольку традиционный NFA конструирует определенные расширения регулярного выражения для поиска соответствий, он может искать подвыражения и backreferences. Но из-за откатов традиционный NFA может проверять одно и то же место несколько раз. В результате работает он медленнее. Поскольку традиционный NFA принимает первое найденное соответствие, он может и не найти самое длинное из вхождений. Именно такие механизмы регулярных выражений используются в Perl, Python, Emacs, Tcl и .Net.
3. POSIX NFA — машины похожи на традиционные NFA-машины, за исключением «терпеливости» – они продолжают поиск, пока не найдут самое длинное соответствие. Поэтому POSIX NFA-машины медленнее традиционных, и поэтому же нельзя заставить POSIX NFA предпочесть более короткое соответствие длинному. Одно из главных достоинств POSIX NFA-машины – наличие стандартной реализации.

Чаще всего программисты используют традиционные NFA-машины, поскольку они точнее, чем DFA или POSIX NFA. Хотя в наихудшем случае время их работы растет по экспоненте, использование образцов, снижающих уровень неоднозначности и ограничивающих глубину поиска с возвратом (backtracking), позволяет управлять их поведением, уменьшая время поиска до приемлемых значений.

Граница слова: \b

Привязка указывает, что соответствие должно находиться на границе между символом слова (языковым элементом ) и несловесным символом (языковым элементом ). Символы слов — это буквенно-цифровые символы и подчеркивания; несловесные символы — это все остальные символы. (См. дополнительные сведения см. о классах символов.) Соответствие может также находиться на границе слова в начале или конце строки.

Привязку часто используют, чтобы убедиться, что часть выражения соответствует всему слову, а не просто окончанию или началу слова. Регулярное выражение в следующем примере демонстрируется использование этой привязки. Она соответствует любому слову, которое начинается с подстроки are. Выходные данные в этом примере также показывают, что соответствует началу и концу входной строки.

Возможные интерпретации шаблона регулярного выражения показаны в следующей таблице.

Объект RegExp

Объект типа , или, короче, регулярное выражение, можно создать двумя путями

/pattern/флаги
new RegExp("pattern")

— регулярное выражение для поиска (о замене — позже), а флаги — строка из любой комбинации символов (глобальный поиск), (регистр неважен) и (многострочный поиск).

Первый способ используется часто, второй — иногда. Например, два таких вызова эквивалентны:

var reg = /ab+c/i
var reg = new RegExp("ab+c", "i")

При втором вызове — т.к регулярное выражение в кавычках, то нужно дублировать

// эквивалентны
re = new RegExp("\\w+")
re = /\w+/

При поиске можно использовать большинство возможностей современного PCRE-синтаксиса.

Символьные классы — \d \w \s и .

\d соответствует одному символу, который является цифрой -> тест\w соответствует слову (может состоять из букв, цифр и подчёркивания) -> тест\s соответствует символу пробела (включая табуляцию и прерывание строки). соответствует любому символу -> тест

Используйте оператор с осторожностью, так как зачастую класс или отрицаемый класс символов (который мы рассмотрим далее) быстрее и точнее. У операторов , и также есть отрицания ― исоответственно

У операторов , и также есть отрицания ― исоответственно.

Например, оператор будет искать соответствия противоположенные .

\D соответствует одному символу, который не является цифрой -> тест

Некоторые символы, например , необходимо выделять обратным слешем .

\$\d соответствует строке, в которой после символа $ следует одна цифра -> тест

Непечатаемые символы также можно искать, например табуляцию , новую строку , возврат каретки .

Обратные ссылки

Всякий раз, когда мы сопоставляем что-либо в круглых скобках, это значение фактически сохраняется в переменной, к которой мы можем обратиться позже в регулярном выражении. Для доступа к этой переменной мы используем escape-символ (), за которым следует цифра. Первый набор скобок обозначается как , второй — и т.д.

Допустим, нам нужно найти строки с двумя упоминаниями о человеке с фамилией Smith. При этом, мы не знаем его имени. Мы могли бы сделать следующее:

В этом примере мы сопоставляем текст между двумя экземплярами Джона Смита, но в этом случае, это нормально, поскольку мы не слишком обеспокоены тем, что было сопоставлено, нам важно только наличие совпадения

Как сопоставить слово в строке (слово границы \ b)?

Итак, как мы можем решить проблему, что точное совпадение словом также будет получать соответствующие подстроки, которые происходят в любой точке строки?

Вот пример:

>>> 'no' in 'nobody knows'
True

И еще один пример:

>>> re.search('see', 'dfjkyldsssseels')

Что, если вы хотите подобрать только целые слова – не точные подстроки? Ответ прост: используйте слово границы Metacharacter Отказ Этот метачаренок совпадает с началом и концом каждого слова – но он ничего не потребляет. Другими словами, он просто проверяет, начинается ли слово или заканчивается в этой позиции (путем проверки пробелов или символов без слова).

Вот как вы используете граничный символ слова, чтобы убедиться, что только целые слова совпадают:

>>> import re
>>> re.search(r'\bno\b', 'nobody knows')
>>> 
>>> re.search(r'\bno\b', 'nobody knows nothing - no?')

В обоих примерах вы используете одно и то же Regex что ищет точное слово Но только если слово границы символа совпадает до и после. Другими словами, слово должен появиться самостоятельно как отдельное слово. Не разрешено появляться в другой последовательности символов слова.

В результате Regex не совпадает в строке Но это соответствует строке Отказ

Обратите внимание, что мы используем сырую строку Чтобы написать регулярное выражение, чтобы побегнуть последовательность работает в строке. Без сырой струны Python предположил бы, что это неизмеренная обратная косая черта следуют персонаж Отказ С сырой строкой все обратные косания будут просто так: обратные косание

Затем двигатель REGEX затем интерпретирует два символа в виде одного специального Metacharacter: граница слова Отказ

Но что, если вам все равно, является ли слово верхним или строчным или заглавным? Другими словами:

Различия синтаксиса регулярных выражений

Реально только в синтаксис Perl использование регулярных выражений встроено непосредственно. В остальных языках для этого используются методы классов. Так, например, в C# работа с регулярными выражениями выглядит следующим образом:

Regex re = new Regex("pattern", "options");
MatchCollection mc = re.Matches("this is just one test");
iCountMatchs = mc.Count;

где re – это новый объект-Regex, в чьем конструкторе передается образец поиска (pattern) и опции (options) (Таблица 1), задающие различные варианты поиска

Таблица 1. Опции Regex.

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

Ниже приведен пример на VB 6, использующий внешнюю библиотеку VBScript RegExp, поставляемую с MS Scripting Host. Ее можно скачать с сайта Microsoft (или найти vbscript.dll в большинстве его продуктов). Этот пример разбирает строку и помещает найденные вхождения в список List1.

Dim re As New VBScript_RegExp.RegExp
Dim matchs As MatchCollection
re.Pattern = "pattern"
re.Global = True ' для поиска по всему тексту.
Set matchs = re.Execute("this is just one test")
Dim m As VBScript_RegExp.Match
List1.Clear
For Each m In matchs
    List1.AddItem m.Value & " Ndx " & m.FirstIndex & " Len " & m.Length
Next

В других языках все выглядит аналогично.

Perl разделяет составные части определения регулярного выражения символами «/». Выглядит это примерно так:

expression =~ m/pattern/

Такое выражение выполняет поиск подстроки, соответствующий шаблону ‘pattern’ в строке expression и возвращает найденные подстроки ($1, $2, $3, …). «m» означает «match», т.е. соответствие. Например,

$test = "this is just one test";
$test =~ m/(o.e)/

вернет «one» в $1.

Для замены применяется выражение

expression =~ s/pattern/new text/

Это выражение, как несложно догадаться, заменяет «pattern» на «new text». Например:

$test = "this is just one test";
$test =~ s/one/my/

заменит one на my, в результате давая «this is just my test», сохраняемое в $test.

В Perl используются те же опции, что и в .Net, кроме «n» и «r». В других реализациях библиотек регулярных выражений опций меньше, либо вовсе нет. Так, в приведенном выше примере на VB настройки производятся через свойства объекта RegExp. Ниже примеры будут даваться в основном в стиле Perl.

Границы слова

Сопоставитель границ \ b соответствует границе слова, что означает местоположение во входной строке, где слово либо начинается, либо заканчивается:

String text = "Mary had a little lamb";

Pattern pattern = Pattern.compile("\\b");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

Этот пример соответствует всем границам слов, найденным во входной строке.

Found match at: 0 to 0
Found match at: 4 to 4
Found match at: 5 to 5
Found match at: 8 to 8
Found match at: 9 to 9
Found match at: 10 to 10
Found match at: 11 to 11
Found match at: 17 to 17
Found match at: 18 to 18
Found match at: 22 to 22

В выводе перечислены все места, где слово либо начинается, либо заканчивается во входной строке. Как видите, индексы начала слова указывают на первый символ слова, тогда как окончания слова указывают на первый символ после слова.

String text = "Mary had a little lamb";

Pattern pattern = Pattern.compile("\\bl");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

В этом примере будут найдены все места, где слово начинается с буквы l (строчные буквы). Фактически он также найдет концы этих совпадений, что означает последний символ шаблона, который является строчной буквой l.

Несловесные границы

String text = "Mary had a little lamb";

Pattern pattern = Pattern.compile("\\B");
Matcher matcher = pattern.matcher(text);

while(matcher.find()){
    System.out.println("Found match at: "  + matcher.start() + " to " + matcher.end());
}

Found match at: 1 to 1
Found match at: 2 to 2
Found match at: 3 to 3
Found match at: 6 to 6
Found match at: 7 to 7
Found match at: 12 to 12
Found match at: 13 to 13
Found match at: 14 to 14
Found match at: 15 to 15
Found match at: 16 to 16
Found match at: 19 to 19
Found match at: 20 to 20
Found match at: 21 to 21

В теории формальных языков[править]

Регулярные выражения состоят из констант и операторов, которые определяют множества строк и множества операций на них соответственно. На данном конечном алфавите Σ определены следующие константы:

• (пустое множество) ∅ обозначает ∅
• (пустая строка) ε обозначает множество {ε}
• (строка) a в Σ обозначает множество {a}

и следующие операции:

• (связь, конкатенация) RS обозначает множество { αβ | α из R и β из S }. Пример: {«ab», «c»}{«d», «ef»} = {«abd», «abef», «cd», «cef»}.
• (перечисление) R|S обозначает объединение R и S.
• (замыкание Клини, звезда Клини) R* обозначает минимальное надмножество из R, которое содержит ε и закрыто связью строк. Это есть множество всех строк, которые могут быть получены связью нуля или более строк из R. Например, {«ab», «c»}* = {ε, «ab», «c», «abab», «abc», «cab», «cc», «ababab», … }.

Многие книги используют символы ∪, + или ∨ для перечисления вместо вертикальной черты.

Пример использования всех основных функций

import re

match = re.search(r'\d\d\D\d\d', r'Телефон 123-12-12')
print(match.group(0) if match else 'Not found')
# -> 23-12
match = re.search(r'\d\d\D\d\d', r'Телефон 1231212')
print(match.group(0) if match else 'Not found')
# -> Not found

match = re.fullmatch(r'\d\d\D\d\d', r'12-12')
print('YES' if match else 'NO')
# -> YES
match = re.fullmatch(r'\d\d\D\d\d', r'Т. 12-12')
print('YES' if match else 'NO')
# -> NO

print(re.split(r'\W+', 'Где, скажите мне, мои очки??!'))
# -> 

print(re.findall(r'\d\d\.\d\d\.\d{4}',
                 r'Эта строка написана 19.01.2018, а могла бы и 01.09.2017'))
# -> 

for m in re.finditer(r'\d\d\.\d\d\.\d{4}', r'Эта строка написана 19.01.2018, а могла бы и 01.09.2017'):
    print('Дата', m.group(0), 'начинается с позиции', m.start())
# -> Дата 19.01.2018 начинается с позиции 20
# -> Дата 01.09.2017 начинается с позиции 45

print(re.sub(r'\d\d\.\d\d\.\d{4}',
             r'DD.MM.YYYY',
             r'Эта строка написана 19.01.2018, а могла бы и 01.09.2017'))
# -> Эта строка написана DD.MM.YYYY, а могла бы и DD.MM.YYYY

Тонкости экранирования в питоне ()

Так как символ в питоновских строках также необходимо экранировать, то в результате в шаблонах могут возникать конструкции вида .
Первый слеш означает, что следующий за ним символ нужно оставить «как есть». Третий также.
В результате с точки зрения питона означает просто два слеша .
Теперь с точки зрения движка регулярных выражений, первый слеш экранирует второй.
Тем самым как шаблон для регулярки означает просто текст .
Для того, чтобы не было таких нагромождений слешей, перед открывающей кавычкой нужно поставить символ , что скажет питону «не рассматривай \ как экранирующий символ (кроме случаев экранирования открывающей кавычки)».
Соответственно можно будет писать .

Использование дополнительных флагов в питоне

Как сопоставить слово в строке (нечувствителен к регистру)?

Вы можете искать точное слово в строке – но игнорируйте капитализацию. Таким образом, это будет неактуально, являются ли символы слова строчными или прописными буквами. Вот как:

>>> import re
>>> re.search('no', 'NONONON', flags=re.IGNORECASE)

>>> re.search('no', 'NONONON', flags=re.I)

>>> re.search('(?i)no', 'NONONON')

Все три способа эквивалентны: все они игнорируют капитализацию букв слова. Если вам нужно узнать больше о Аргумент в Python, проверьте мой Подробное руководство по этому блогу Отказ Третий пример использует флаг In-Regex Это также означает: «игнорировать капитализацию».

Повторы¶

Повтор

За любым элементом регулярного выражения может следовать допустимое число повторений элемента.

То есть цифры в фигурных скобках определяются минимальное и максимальное количество повторов (совпадений во входном тексте).

эквивалентно и означает . совпадает или более раз.

Теоретически значение n и m не ограничены (можно использовать максимальное значение для 32-х битного числа).

Жадность

в режиме захватывают как можно больше из входного текста, в режиме — как можно меньше.

По умолчанию все повторы являются . Используйте Чтобы сделать любой повтор .

Для строки :

Вы можете переключить все повторы в режим (, ниже мы используем ).

Регулярные выражения в питоне

Мы будем использовать модуль :

Функция возвращает первое вхождение подстроки, которая подходит под регулярное выражение

Обратите внимание на порядок аргументов: первый — это регулярное выражение, второй — исходная строка, в которой мы ищем

возвращает объект (или , если ничего не нашлось), из которого затем можно извлечь результат методом :

Ещё одна полезная функция находит все вхождения подходящих строк:

“Сырые” (raw) строки

Для регулярных выражений в питоне лучше использовать синтаксис для «сырых» (raw) строк. Если добавить в начале строки (), то питон будет обрабатывать эту строку не как обычную, а как сырую.

Зачем это нужно? В регулярных выражениях для экранирования специальных символов используется – например, обозначает точку, – плюс, и т. д. Но когда питон читает обычные, не “сырые” строки (ещё до того, как мы с этой строкой что-то сделали), он тоже использует для экранирования символов, но по-другому (например – это перенос строки, – табуляция, а – буквально символ ). Из-за различий в правилах экранирования может возникнуть путаница – например, при попытке обработать строку как обычную, не как “сырую”, питон выдаст синтаксическую ошибку, потому что он не знает, во что преобразовать . Другой пример – в синтаксисе регулярных выражений обозначает границу слова, а в синтаксисе питоновских строк – символ backspace (поэтому, когда мы не используем “сырые” строки, преобразуется в backspace).

Предположим, нам нужно написать регулярное выражение, соответствующее подстроке . В синтаксисе регулярных выражений оно будет выглядеть так: (символ должен быть экранирован). Но, если мы не используем “сырые” строки, то нам придётся записать его как – оба символа должны быть экранированы ещё раз, чтобы питон их правильно прочитал. Довольно неудобно.

В “сырых” строках питон ничего не экранирует, а читается как обычный символ и экранируется только в регулярном выражении, поэтому путаницы не возникает. Например, на мы получим

a на –

Соответственно, “сырая” строка с регулярным выражением для поиска подстроки будет выглядеть просто как .

Кроме того, “сырые” строки удобно использовать для хранения пути к файлам в Windows (например ), так как там тоже используется .

Ограничение: “сырые” строки не могут содержать нечётное количество символов в конце.

Найдем все числа в строке:

Примеры регулярных выражений

Любой символ кроме новой строки

Точки в строке

Любая цифра

Все, кроме цифры

Любая буква или цифра

Все, кроме букв и цифр

Только буквы

Соответствие заданное количество раз

1 и более вхождений

Любое количество вхождений (0 или более раз)

0 или 1 вхождение

Граница слова Границы слов обычно используются для обнаружения и сопоставления началу или концу слова. То есть, одна сторона является символом слова, а другая сторона является пробелом и наоборот.

Например, регулярное выражение совпадает с ‘toy’ в ‘toy cat’, но не в ‘tolstoy’. Для того, чтобы ‘toy’ соответствовало ‘tolstoy’, используйте . Можете ли вы придумать регулярное выражение, которое будет соответствовать только первой ‘toy’в ‘play toy broke toys’? (подсказка: с обеих сторон) Аналогично, будет соответствовать любому non-boundary( без границ). Например, будет соответствовать ‘toy’, окруженной словами с обеих сторон, как в ‘antoynet’.