Модуль Re для регулярных выражений в Python

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

Работать с регулярными выражениями позволяет специальный модуль – re. Причем позволяет осуществлять все операции с ними, начиная их использованием и заканчивая обработкой ошибок. Так, если при компиляции или использовании регулярного выражения возникает проблема, происходит исключение re.error. Рассмотрим функции, которые могут применяться для процессинга регулярных выражений.

Учтите то, что некоторые символы изменяют свой смысл, когда становятся составляющей частью регулярного выражения.

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

r’expression’

Что такое регулярные выражения?

Зачем вообще нужны регулярные выражения? Да так, что они используются в огромном количестве языков программирования. Они используются в разных ситуациях:

1. Если необходимо сравнить, соответствует ли элемент строки какому-то шаблону. Как вариант, относится ли элемент к телефонному номеру или адресу электронной почты. 
2. Замена символов. Есть широкий набор методов работы с регулярными выражениями и самих выражений, позволяющих находить нужные вхождения и заменять их на те, которые нужны пользователю или разработчику.
3. Извлечение. Регулярные выражения могут работать в одну сторону, лишь извлекая информацию. Например, можно извлечь из строки обращение к человеку ( Mr., например).
4. Портируемость. Почти любой язык программирования содержит библиотеку регулярных выражений. При этом синтаксис стандартизирован. Это удобно, поскольку не нужно заново изучать его при обучении новому языку. Достаточно изучить регулярные выражения один раз.
5. Код. Регулярные выражения отлично подходят для поиска данных в файлах.
6. Четкость и лаконичность. Регулярные выражения позволяют значительно упростить многие команды, сведя их к одному шаблону или символу. На написание кода с регулярными выражениями уходит значительно меньше времени, а сам он выглядит более читаемым. Это полезно в ситуациях, когда над одной программой работает несколько человек. 

Методы, использующиеся для работы с регулярными выражениями

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

Match

Этот метод осуществляет поиск определенной строки регулярного выражения в большей строке. Задать параметры этой функции можно с помощью специальных модификаторов.

Синтаксис функции:

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

Функция использует следующие аргументы (от первого по третий в соответствии с описанным выше синтаксисом):

1. Строка используемого регулярного выражения. Необходимо записывать в приведенном выше формате. Сначала ставится буква r, после чего открывается кавычка и записывается непосредственно строка с шаблоном. Например, (r’g.{3}le’).
2. Строка, в которой будет искаться соответствие. Например, под приведенное выше описание подходит слово «google».
3. Дополнительные параметры или, как их еще называют, модификаторы. 

Если функция полностью выполняется, она возвращает объект match. Если же возникает ошибка, – None. Чтобы узнать итоги поиска, применяем функцию group(num) или groups(). Это – метод объекта match. Следовательно, его надо вызывать через точку, как и любой другой объект. 

В качестве аргумента функции group() используется номер. По умолчанию используется номер 0. Этот метод получает полное совпадение и передает его пользователю.

А вот метод groups() возвращает все подгруппы, которые удалось обнаружить в формате кортежа.

Теперь давайте для наглядности продемонстрируем пример использования этой функции.  

import re




title = "Error 404. Page not found"

exemple = re.match( r'(.*)\. (.*?) .*', title, re.M|re.I)




if exemple:

   print("exemple.group() : ", exemple.group())

   print("exemple.group(1) : ", exemple.group(1))

   print("exemple.group(2) : ", exemple.group(2))

   print("exemple.groups():", exemple.groups())

else:

   print("Нет совпадений!")

Что будет, если выполнить этот код? Он выдаст в трех случаях ошибку, и в одном случае – слово «Page».

Search

Этот метод пытается найти первый экземпляр, соответствующий строке регулярного выражения внутри строки, которая записывается во втором аргументе. Синтаксис этого метода такой же самый, как и у прошлого. Сначала записывается строка регулярного выражения, потом – строка, в которой осуществляется поиск первого вхождения, соответствующего шаблону, указанному в первом аргументе. А в третьем записываются модификаторы.

И в этом, и в предыдущем методах можно указать различных модификаторы, используя побитовый оператор OR.

После того, как метод выполнит свои действия, он выдаст значение, относящееся к объекту класса match в случае обнаружения совпадения. Если же его не удалось обнаружить, то тогда возвращается None. Одним словом, все аналогично предыдущему примеру. 

И точно так же, как и в прошлом методе, возможно использование функций group(num), groups, относящиеся к объекту класса match для того, чтобы получить результаты функции. 

Теперь давайте перейдем к примеру. 

import re




title = "Error 404. Page not found"

# добавим пробел в начало паттерна

exemple = re.search( r' (.*)\. (.*?) .*', title, re.M|re.I)




if exemple:

   print("exemple.group():", exemple.group())

   print("exemple.group(1):", exemple.group(1))

   print("exemple.group(2):", exemple.group(2))

   print("exemple.groups():", exemple.groups())

else:

   print("Нет совпадений!")

После запуска скрипта также в третьей строке будет выдана строка «Page». 

Разница между Match и Search

Хорошо, а в чем же разница между этими методами? Ведь синтаксис у них одинаковый, возвращают одно и то же значение. Принципиальная разница между ними заключается в том, что первый метод выполняет поиск исключительно до первого вхождения, в то время как функция search() предназначена для того, чтобы искать элемент по всей строке.

Значительно проще продемонстрировать эту разницу на реальном примере. 

import re





title = "Error 404. Page not found"

match_exemple = re.match( r'not', title, re.M|re.I)




if match_exemple:

   print("match --> match_exemple.group():", match_exemple.group())

else:

   print("Нет совпадений!")




search_exemple = re.search( r'not', title, re.M|re.I)

if search_exemple:

   print("search --> search_exemple.group():", search_exemple.group())

else:

   print("Нет совпадений!")

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

search —> search_exemple.group(): not

Sub

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

re.sub(pattern, repl, string)

Разберем аргументы по порядку:

1. Вхождения, которые заменяются.
2. Строка, на которую нужно осуществить замену этого вхождения.
3. Строка, в которой осуществляется поиск вхождения. 

А теперь приведем пример использования этого метода. 

import re


born = "05-03-1987 # Дата рождения"




# Удалим комментарий из строки

dob = re.sub(r'#.*$', "", born)

print("Дата рождения:", dob)




# Заменим дефисы на точки

f_dob = re.sub(r'-', ".", born)    

print(f_dob)

Модификаторы регулярных выражений

Описанные выше функции содержат модификатор. Это – необязательный компонент, который используется для того, чтобы задавать условия поиска. Если необходимо указать больше одного модификатора, используется символ побитового ИЛИ. Выглядит он, как «|». 

Опишем существующие модификаторы регулярных выражений.

1. re.I. Если необходимо сделать так, чтобы поиск не учитывал большие или маленькие буквы, необходимо использовать этот модификатор.
2. re.L. Учитывает язык при поиске. 
3. re.M. Задает такие правила: символ $ ищет в конце любой строки (не только лишь в конце текста), а символ ^ ищет в начале любой строки.
4. re.S. Заменяет точку на совпадение с любым символом. Новая строка также учитывается.
5. re.U. Осуществляет интерпретацию букв, основываясь на наборе символов Unicode. Этот модификатор стоит по умолчанию в Python 3 версии и старше.
6. re.X. Дает возможность использовать несколько строк регулярного выражения, не учитывает пробелы внутри паттерна (единственное исключение – пробелы внутри набора [] или в ходе экранирования обратным слешем) и осуществляет обработку не экранированного #, как комментария.

Шаблоны регулярных выражений

Большинство символов соответствуют самим себе. Но есть некоторые специальные символы, которые используются в качестве шаблонов. Они кодируют определенную информацию, на основании которой интерпретатор понимает, что ему надо делать.

Таких шаблонов большое количество. Мы приведем примеры некоторых из них.

1. ^. Обозначает начало строки.
2. $. Обозначает конец строки. 
3. . – указывает на какой-угодно символ, за исключением новой строки. Если использовать модификатор re.M, позволяет соответствовать новой строке. 
4. [4fw] – обозначает любой символ в скобках. 
5. [^4fw] – обозначает те символы, которые не находятся в квадратных скобках.

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