Как создать регулярное выражение python
Перейти к содержимому

Как создать регулярное выражение python

  • автор:

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

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

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

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

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

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

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

Что такое шаблон регулярного выражения и как его скомпилировать?

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

Основным примером является \s+ .
Здесь \ s соответствует любому символу пробела. Добавив в конце оператор + , шаблон будет иметь не менее 1 или более пробелов. Этот шаблон будет соответствовать даже символам tab \t .

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

>>> import re >>> regex = re.compile('\s+') 

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

Как разбить строку, разделенную регулярным выражением?

Рассмотрим следующий фрагмент текста.

>>> text = """100 ИНФ Информатика 213 МАТ Математика 156 АНГ Английский""" 

У меня есть три курса в формате “[Номер курса] [Код курса] [Название курса]”. Интервал между словами разный.

Передо мной стоит задача разбить эти три предмета курса на отдельные единицы чисел и слов. Как это сделать?
Их можно разбить двумя способами:

  • Используя метод re.split .
  • Вызвав метод split для объекта regex .
# Разделит текст по 1 или более пробелами >>> re.split('\s+', text) # или >>> regex.split(text) ['100', 'ИНФ', 'Информатика', '213', 'МАТ', 'Математика', '156', 'АНГ', 'Английский'] 

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

Поиск совпадений с использованием findall, search и match

Предположим, вы хотите извлечь все номера курсов, то есть 100, 213 и 156 из приведенного выше текста. Как это сделать?

Что делает re.findall()?

#найти все номера в тексте >>> print(text) 100 ИНФ Информатика 213 МАТ Математика 156 АНГ Английский >>> regex_num = re.compile('\d+') >>> regex_num.findall(text) ['100', '213', '156'] 

В приведенном выше коде специальный символ \ d является регулярным выражением, которое соответствует любой цифре. В этой статье вы узнаете больше о таких шаблонах.
Добавление к нему символа + означает наличие по крайней мере 1 числа.

Подобно + , есть символ * , для которого требуется 0 или более чисел. Это делает наличие цифры не обязательным, чтобы получилось совпадение. Подробнее об этом позже.

В итоге, метод findall извлекает все вхождения 1 или более номеров из текста и возвращает их в список.

re.search() против re.match()

Как понятно из названия, regex.search() ищет шаблоны в заданном тексте.
Но, в отличие от findall , который возвращает согласованные части текста в виде списка, regex.search() возвращает конкретный объект соответствия. Он содержит первый и последний индекс первого соответствия шаблону.

Аналогично, regex.match() также возвращает объект соответствия. Но разница в том, что он требует, чтобы шаблон находился в начале самого текста.

>>> # создайте переменную с текстом >>> text2 = """ИНФ Информатика 213 МАТ Математика 156""" >>> # скомпилируйте regex и найдите шаблоны >>> regex_num = re.compile('\d+') >>> s = regex_num.search(text2) >>> print('Первый индекс: ', s.start()) >>> print('Последний индекс: ', s.end()) >>> print(text2[s.start():s.end()]) Первый индекс: 17 Последний индекс: 20 213 

В качестве альтернативы вы можете получить тот же результат, используя метод group() для объекта соответствия.

>>> print(s.group()) 205 >>> m = regex_num.match(text2) >>> print(m) None 

Как заменить один текст на другой, используя регулярные выражения?

Для изменения текста, используйте regex.sub() .
Рассмотрим следующую измененную версию текста курсов. Здесь добавлена табуляция после каждого кода курса.

# создайте переменную с текстом >>> text = """100 ИНФ \t Информатика 213 МАТ \t Математика 156 АНГ \t Английский""" >>> print(text) 100 ИНФ Информатика 213 МАТ Математика 156 АНГ Английский 

Из вышеприведенного текста я хочу удалить все лишние пробелы и записать все слова в одну строку.

Для этого нужно просто использовать regex.sub для замены шаблона \s+ на один пробел .

# заменить один или больше пробелов на 1 >>> regex = re.compile('\s+') >>> print(regex.sub(' ', text)) 
>>> print(re.sub('\s+', ' ', text)) 101 COM Computers 205 MAT Mathematics 189 ENG English 

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

Это можно сделать, используя отрицательное соответствие (?!\n) . Шаблон проверяет наличие символа новой строки, в python это \n , и пропускает его.

# убрать все пробелы кроме символа новой строки >>> regex = re.compile('((?!\n)\s+)') >>> print(regex.sub(' ', text)) 100 ИНФ Информатика 213 МАТ Математика 156 АНГ Английский 

Группы регулярных выражений

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

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

>>> text = """100 ИНФ Информатика 213 МАТ Математика 156 АНГ Английский""" # извлечь все номера курсов >>> re.findall('[0-9]+', text) # извлечь все коды курсов (для латиницы [A-Z]) >>> re.findall('[А-ЯЁ]', text) # извлечь все названия курсов >>> re.findall('[а-яА-ЯёЁ]', text) ['100', '213', '156'] ['ИНФ', 'МАТ', 'АНГ'] ['Информатика', 'Математика', 'Английский'] 

Давайте посмотрим, что получилось.
Я скомпилировал 3 отдельных регулярных выражения по одному для соответствия номерам курса, коду и названию.
Для номера курса, шаблон [0-9]+ указывает на соответствие всем числам от 0 до 9. Добавление символа + в конце заставляет найти по крайней мере 1 соответствие цифрам 0-9. Если вы уверены, что номер курса, будет иметь ровно 3 цифры, шаблон мог бы быть [0-9] .

Для кода курса, как вы могли догадаться, [А-ЯЁ] будет совпадать с 3 большими буквами алфавита А-Я подряд (буква “ё” не включена в общий диапазон букв).

Для названий курса, [а-яА-ЯёЁ] будем искать а-я верхнего и нижнего регистра, предполагая, что имена всех курсов будут иметь как минимум 4 символа.

Можете ли вы догадаться, каков будет шаблон, если максимальный предел символов в названии курса, скажем, 20?
Теперь мне нужно написать 3 отдельные строки, чтобы разделить предметы. Но есть лучший способ. Группы регулярных выражений.
Поскольку все записи имеют один и тот же шаблон, вы можете создать единый шаблон для всех записей курса и внести данные, которые хотите извлечь из пары скобок ().

# создайте группы шаблонов текста курса и извлеките их >>> course_pattern = '([0-9]+)\s*([А-ЯЁ])\s*([а-яА-ЯёЁ])' >>> re.findall(course_pattern, text) [('100', 'ИНФ', 'Информатика'), ('213', 'МАТ', 'Математика'), ('156', 'АНГ', 'Английский')] 

Обратите внимание на шаблон номера курса: [0-9]+ , код: [А-ЯЁ] и название: [а-яА-ЯёЁ] они все помещены в круглую скобку (), для формирования группы.

Что такое “жадное” соответствие в регулярных выражениях?

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

Давайте рассмотрим пример фрагмента HTML, где нам необходимо получить тэг HTML.

>>> text = "Пример жадного соответствия регулярных выражений" >>> re.findall('<.*>', text) ['Пример жадного соответствия регулярных выражений'] 

Вместо совпадения до первого появления ‘>’, которое, должно было произойти в конце первого тэга тела, он извлек всю строку. Это по умолчанию “жадное” соответствие, присущее регулярным выражениям.

С другой стороны, ленивое соответствие “берет как можно меньше”. Это можно задать добавлением ? в конец шаблона.

>>> re.findall('<.*?>', text) ['', ''] 

Если вы хотите получить только первое совпадение, используйте вместо этого метод поиска search .

re.search('<.*?>', text).group() '' 

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

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

Основной синтаксис

. Один символ кроме новой строки
\. Просто точка . , обратный слеш \ убирает магию всех специальных символов.
\d Одна цифра
\D Один символ кроме цифры
\w Один буквенный символ, включая цифры
\W Один символ кроме буквы и цифры
\s Один пробельный (включая таб и перенос строки)
\S Один не пробельный символ
\b Границы слова
\n Новая строка
\t Табуляция

Модификаторы

$ Конец строки
^ Начало строки
ab|cd Соответствует ab или de.
[ab-d] Один символ: a, b, c, d
[^ab-d] Любой символ, кроме: a, b, c, d
() Извлечение элементов в скобках
(a(bc)) Извлечение элементов в скобках второго уровня

Повторы

[ab]

2 непрерывных появления a или b
[ab]

от 2 до 5 непрерывных появления a или b
[ab]

2 и больше непрерывных появления a или b
+ одно или больше
* 0 или больше
? 0 или 1

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

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

>>> text = 'python.org' >>> print(re.findall('.', text)) # Любой символ кроме новой строки ['p', 'y', 't', 'h', 'o', 'n', '.', 'o', 'r', 'g'] >>> print(re.findall('. ', text)) ['pyt', 'hon', '.or'] 

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

>>>text = 'python.org' >>> print(re.findall('\.', text)) # соответствует точке ['.'] >>> print(re.findall('[^\.]', text)) # соответствует всему кроме точки ['p', 'y', 't', 'h', 'o', 'n', 'o', 'r', 'g'] 

Любая цифра

>>> text = '01, Янв 2018' >>> print(re.findall('\d+', text)) # Любое число (1 и более цифр подряд) ['01', '2018'] 

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

>>> text = '01, Янв 2018' >>> print(re.findall('\D+', text)) # Любая последовательность, кроме цифр [', Янв '] 

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

>>> text = '01, Янв 2018' >>> print(re.findall('\w+', text)) # Любой символ(1 или несколько подряд) ['01', 'Янв', '2018'] 

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

>>> text = '01, Янв 2018' >>> print(re.findall('\W+', text)) # Все кроме букв и цифр [', ', ' '] 

Только буквы

>>> text = '01, Янв 2018' >>> print(re.findall('[а-яА-ЯёЁ]+', text)) # Последовательность букв русского алфавита ['Янв'] 

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

>>> text = '01, Янв 2018' >>> print(re.findall('\d', text)) # Любые 4 цифры подряд ['2018'] >>> print(re.findall('\d', text)) ['01', '2018'] 

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

>>> print(re.findall(r'Co+l', 'So Cooool')) # 1 и более буква 'o' в строке ['Cooool'] 

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

>>> print(re.findall(r'Pi*lani', 'Pilani')) ['Pilani'] 

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

>>> print(re.findall(r'colou?r', 'color')) ['color'] 

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

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

>>> re.findall(r'\btoy\b', 'play toy broke toys') # соедини toy с ограничениями с обеих сторон ['toy'] 

Практические упражнения

Давайте немного попрактикуемся. Пришло время открыть вашу консоль. (Варианты ответов здесь)

1. Извлеките никнейм пользователя, имя домена и суффикс из данных email адресов.

emails = """zuck26@facebook.com page33@google.com jeff42@amazon.com""" # требуеый вывод [('zuck26', 'facebook', 'com'), ('page33', 'google', 'com'), ('jeff42', 'amazon', 'com')] 

2. Извлеките все слова, начинающиеся с ‘b’ или ‘B’ из данного текста.

text = """Betty bought a bit of butter, But the butter was so bitter, So she bought some better butter, To make the bitter butter better.""" # требуеый вывод ['Betty', 'bought', 'bit', 'butter', 'But', 'butter', 'bitter', 'bought', 'better', 'butter', 'bitter', 'butter', 'better'] 

3. Уберите все символы пунктуации из предложения

sentence = """A, very very; irregular_sentence""" # требуеый вывод A very very irregular sentence 

4. Очистите следующий твит, чтобы он содержал только одно сообщение пользователя. То есть, удалите все URL, хэштеги, упоминания, пунктуацию, RT и CC.

tweet = '''Good advice! RT @TheNextWeb: What I would do differently if I was learning to code today https://t.co/lbwej0pxOd cc: @garybernhardt #rstats''' # требуеый вывод 'Good advice What I would do differently if I was learning to code today' 
  1. Извлеките все текстовые фрагменты между тегами с HTML страницы: https://raw.githubusercontent.com/selva86/datasets/master/sample.html
    Код для извлечения HTML страницы:
import requests r = requests.get("https://raw.githubusercontent.com/selva86/datasets/master/sample.html") r.text # здесь хранится html # требуеый вывод ['Your Title Here', 'Link Name', 'This is a Header', 'This is a Medium Header', 'This is a new paragraph! ', 'This is a another paragraph!', 'This is a new sentence without a paragraph break, in bold italics.'] 

Ответы

# 1 задание >>> pattern = r'(\w+)@([A-Z0-9]+)\.([A-Z])' >>> re.findall(pattern, emails, flags=re.IGNORECASE) [('zuck26', 'facebook', 'com'), ('page33', 'google', 'com'), ('jeff42', 'amazon', 'com')] 
# 2 задание >>> import re >>> re.findall(r'\bB\w+', text, flags=re.IGNORECASE) ['Betty', 'bought', 'bit', 'butter', 'But', 'butter', 'bitter', 'bought', 'better', 'butter', 'bitter', 'butter', 'better'] 

\b находится слева от ‘B’, значит слово должно начинаться на ‘B’.
Добавьте flags=re.IGNORECASE , что бы шаблон был не чувствительным к регистру.

# 3 задание >>> import re >>> " ".join(re.split('[;,\s_]+', sentence)) 'A very very irregular sentence' 
# 4 задание >>> import re >>> def clean_tweet(tweet): tweet = re.sub('http\S+\s*', '', tweet) # удалит URL tweet = re.sub('RT|cc', '', tweet) # удалит RT и cc tweet = re.sub('#\S+', '', tweet) # удалит хештеги tweet = re.sub('@\S+', '', tweet) # удалит упоминани tweet = re.sub('[%s]' % re.escape("""!"#$%&'()*+,-./:;?@[\]^_`<|>~"""), '', tweet) # удалит символы пунктуации tweet = re.sub('\s+', ' ', tweet) # заменит пробельные символы на 1 пробел return tweet >>> print(clean_tweet(tweet)) 'Good advice What I would do differently if I was learning to code today' 
# 5 задание >>> re.findall('<.*?>(.*)', r.text) ['Your Title Here', 'Link Name', 'This is a Header', 'This is a Medium Header', 'This is a new paragraph! ', 'This is a another paragraph!', 'This is a new sentence without a paragraph break, in bold italics.'] 

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

  • ТЕГИ
  • Регулярные выражения

Регулярные выражения в Python для новичков

Регулярные выражения в Python для новичков

У вас когда-нибудь возникала потребность в поиске строк, слов или даже символов в тексте?

В этой статье вы узнаете о регулярных выражениях в Python и научитесь работать с модулем «re», который позволяет совершать массу сравнительных и поисковых действий с текстом!

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

Регулярное выражение – это средство работы с текстом, которое позволяет по заданному «паттерну» искать и редактировать искомое слово/строку в тексте.

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

Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей

Импортируем модуль «re»

Для начала работы нам нужно импортировать модуль.

Модуль «re» устанавливать не нужно, он устанавливается вместе с самим Python. Нам лишь нужно импортировать его в проект.

Для этого в начале строки пропишем:

import re

Основные регулярные выражения

re.match() – ищет совпадения в тексте, по умолчанию в начале строки.

import re pattern = ‘34’ testString = ’12 timeweb 34 community 58’ result = re.search(pattern, testString) print(result) # Результат None, если совпадения будут обнаружены - result вернет их.

re.findall() – возвращает все строки, где было обнаружено совпадение.

import re pattern = ‘\d+’ (ищем только числа с помощью метасимволов, об этом далее) testString = ’12 timeweb 34 community 58’ result = re.findall(pattern, testString) print(result) # Результат [‘12’, ‘34’, ‘58’], если совпадения не будут обнаружены - то []

re.split() – разбивает строки по заданному паттерну и возвращает разбитые строки.

import re pattern = ‘\d+’ testString = ’12 timeweb 34 community 58’ result = re.split(pattern, testString) print(result) # Результат [‘timeweb’, ‘community’], если совпадения не будут обнаружены - то []

re.sub() – заменяет символы по заданному паттерну на заданные символы и возвращает исправленную строку.

import re pattern = ‘timeweb’ replace = ‘hello’ testString = ’timeweb community of timeweb community’ result = re.sub(pattern, replace, testString) print(result) # Результат ‘hello community of hello community’, если совпадения не будут обнаружены, то вернется первоначальная строка.

re.search() – ищет указанный паттерн в строке и при первом же совпадении возвращает сам паттерн, в ином же случае возвращает None.

import re pattern = ‘34’ testString = ’12 timeweb 34 community 58’ result = re.search(pattern, testString) print(result) # Результат ‘34’, если совпадения не будут обнаружены - None.

Метасимволы

Давайте рассмотрим примеры использования метасимволов, которые есть в модуле.

К примеру, нам нужно найти слова car, cat и cab.

Дабы не нагромождать наш код, мы можем просто использовать квадратные скобки. В таком случае переменную мы запишем так:

pattern = ‘ca[rtb] ’

Либо же мы можем указать диапазон символов:

pattern = ‘ca[a-e] ‘ (заменяет [abcde]) pattern = ‘ca[1-5] ’ (заменяет [12345]) # Вы можете искать обратные указанным вами символам. # К примеру ‘[^0-9]’ ищет любые символы, кроме чисел; # ‘[0-9]’ ищет все числа.

Также мы можем обозначить, с какой стороны искать совпадения!

pattern = ‘^timeweb’ - ищет в начале pattern = ‘timeweb$’ - ищет в конце

Мы можем обозначить нужное количество символов с помощью периода.

pattern = ‘tim. ’ - ищет tim и следующие три символа в начале

А еще метасимволы можно комбинировать!

pattern = ‘^t. b$’ # Найдет совпадение, если в строке 7 символов, # первым из которых является t, а последним b.

Краткие замены некоторым метасимволам

  • \d — ищет числа в тексте, заменяет [0-9].
  • \D — ищет любые символы кроме чисел в тексте, заменяет ‘[^0-9]’.
  • \s — находит совпадения при наличии пробелов в тексте.
  • \S — находит совпадения при отсутствии пробелов в тексте.

Надеюсь, что данная статья помогла вам разобраться с основами регулярных выражений в Python. Спасибо за внимание!

Регулярные выражения в Python: инструкция, примеры и практика

Регулярные выражения в Python: инструкция, примеры и практика

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

Освойте профессию
«Python-разработчик»

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

Регулярные выражения представляют собой мощные шаблоны для поиска фрагментов в тексте. К примеру, в коде Python-программы есть форма регистрации пользователей. Для регистрации надо обязательно ввести адрес электронной почты. При этом в поле можно ввести совершенно любую строку и нарушить работу программы. Поэтому каким-то образом надо проверить валидность данных.

Python-разработчик
Освойте Python, самый популярный язык программирования
3 383 ₽/мес 6 150 ₽/мес

dffsdd (3)

Первая идея — проверять строку на наличие символа at (@), ведь он есть в каждом адресе электронной почты, но пользователь может ввести email@. Символ есть, но это все еще не адрес электронной почты. Регулярные выражения в Python — это шаблоны, по которым можно проверять валидность данных, искать совпадения в тексте или заменять определенные фрагменты . Плюс таких выражений в том, что они поддерживаются практически во всех языках программирования. Изучив основной принцип работы, можно будет писать «регулярки» в коде любого другого проекта. Регулярное выражение для проверки валидности адреса электронной почты в Python будет выглядеть так:

r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]$'

Напишем код небольшой функции для проверки валидности адресов электронной почты. Наше регулярное выражение поместим в переменную email_pattern, с помощью функции match() будем искать совпадения и возвращать True или False, в зависимости от того, является ли строка адресом электронной почты.

import re email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]$' def is_valid_email(email): return re.match(email_pattern, email) is not None

Теперь создадим несколько переменных с адресами и проверим каждый нашей функцией:

email1 = "user@example.com" email2 = "invalid_email@" email3 = "another.user123@subdomain.domain" print(is_valid_email(email1)) # True print(is_valid_email(email2)) # False print(is_valid_email(email3)) # True

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

Станьте разработчиком на Python и решайте самые разные задачи: от написания кода до автоматизации процессов

Регулярные выражения в Python

Регулярные выражения или RegEx — строки, задающие шаблон для поиска фрагментов в тексте. По сути, RegEx можно назвать узкоспециализированным языком программирования, встроенным в Python. У регулярных выражений есть свой строгий синтаксис, набор функций для проверки совпадений и изменения исходной строки. В Python регулярные выражения доступны в модуле re, который необходимо импортировать в начале файла с помощью import re. Для экранирования обычно используют символ обратного слэша (\) или raw-строки (r»). Рекомендуется использовать второй способ, так как в больших регулярных выражениях и так будет довольно много слэшей.

Читайте также Регулярные выражения в Python: инструкция, примеры и практика

Функции регулярных выражений в Python

re.match() — поиск вхождения шаблона в начало строки. В качестве аргументов требуется передать сначала шаблон, а потом строку для проверки:

import re str = "Банкиров ребрендили-ребрендили-ребрендили, да не выребрендировали" print(re.match(r'ре', str))
  • .group() — возвращает тот фрагмент строки, в котором нашлось совпадение;
  • .span() — возвращает кортеж с начальной и конечной позицией искомого шаблона;
  • .string() — возвращает строку, которую передали в re.search().

re.findall() — поиск всех вхождений шаблона в любом месте строки:

import re str = "Банкиров ребрендили-ребрендили-ребрендили, да не выребрендировали" print(re.findall(r'ре', str, re.IGNORECASE)) >>> ['ре', 'ре', 'ре', 'ре', 'ре', 'ре', 'ре', 'ре']

re.sub() — заменяет фрагменты в соответствии с шаблоном:

import re string = "шел дождь и два студента" result = re.sub(r'два', 'три', string) print(result) >>> шел дождь и три студента

re.split() — разделяет строку по шаблону, количество разделений задается числом:

import re string = "шел дождь и два студента" result = re.split(r' ', string, 4) print(result) >>> ['шел', 'дождь', 'и', 'два', 'студента']
import re string = "шел дождь и два студента" result = re.split(r' ', string, 1) print(result) >>> ['шел', 'дождь и два студента']

Эти функции реализуют базовые возможности регулярных выражений в Python.

Метасимволы регулярных выражений в Python

В примерах выше мы использовали регулярные выражения для поиска конкретных слов и слогов, но возможности технологии предоставляют работу с более продвинутыми шаблонами. К примеру, можно искать последовательности символов или любые символы из заданного диапазона. Сделать это можно с помощью специальных метасимволов.

Метасимвол Зачем нужен Как использовать
. Задает один произвольный символ, кроме новой строки E.am.le
[…] Любой символ в скобках, сами символы можно задавать с помощью перечислений или диапазонов [123abc] — только указанные символы[A-Za-z0-9] — весь английский алфавит и цифры[А-ЯЁа-яё0-9] — весь русский алфавит и цифры
[^…] Любой символ, исключая указанные в скобках, сами символы можно задавать с помощью перечислений или диапазонов [^A-Za-z]
^ Начало строки ^Hello
$ Конец строки Hello$
| Логический оператор ИЛИ. Поиск одного из нескольких указанных вариантов [0-9]|[IVXLCDM] — арабские или римские цифры
\ Экранирование, с помощью которого Python понимает, является ли следующий символ обычным или специальным. Можно обычные символы превращать в метасимволы и обратно \[\.\] — метасимволы становятся обычными\d\W\A — обычные символы становятся метасимволами
* Произвольное число повторений одного символа Hello*
? Строго одно повторение символа Hello?
(…) Группировка символов в скобках ([A-Z][A-Za-z]+)
Число повторений предыдущего символа Hello — строка четыре раза подрядHello — строка от одного до четырех раз подрядHello — строка от четырех раз подрядHello — строка от нуля до четырех раз подряд

Важно отметить, что буквы «Ё» и «ё» не входят в диапазоны [А-Я] и [а-я]. Поэтому их надо отдельно включать, иначе регулярное выражение будет работать с ошибками.

Выше мы говорили про то, что обратный слэш (\) может превращать метасимволы в обычные и наоборот. К примеру, обычная точка (.) будет обозначать произвольный символ, а точка с обратным слэшем (\.) — просто точку. Такой принцип работает и с буквами латинского алфавита, которые становятся метасимволами.

Символ Зачем нужен
\d Любая цифра, заменяет собой запись [0-9]
\D Исключает все цифры, заменяет собой запись [^0-9]
\s Любой пробельный символ, включая пробел, табуляцию, новую строку и возврат каретки
\S Любой символ, исключая пробельный
\w Любая буква, цифра и знак нижнего подчеркивания (_)
\W Любой символ, кроме буквы, цифры и нижнего подчеркивания
\A Начало строки, заменяет собой запись ^
\Z Конец строки, заменяет собой запись $
\b Начало или конец слова
\B Середина слова
\n Новая строка
\t Табуляция
\r Возврат каретки

Флаги регулярных выражений в Python

Расширить возможность регулярных выражений в Python можно с помощью специальных флагов, которые передаются в функцию. С флагом re.IGNORECASE, игнорирующим регистр символов, мы уже познакомились выше. Но есть и другие флаги, ускоряющие работу с «регулярками».

Краткая запись флага Полная запись флага Зачем нужен
re.I re.IGNORECASE Игнорирует регистр символов
re.A re.ASCII Возвращает совпадения только по таблице ASCII-символов
re.X re.VERBOSE Позволяет использовать комментарии в регулярных выражениях
re.S re.DOTALL Метасимвол точка (.) возвращает совпадения по всем символам, включая новую строку.
re.L re.LOCALE Добавляет к \w, \W, \b, \B, \s и \S региональные настройки, но работает только с байтовыми строками
re.M re.MULTILINE Возвращает совпадения в начале каждой новой строки, если используется с ^, и в конце каждой новой строки — если с $

Практические задачи

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

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

Задача 1

Вернуть первое слово из строки «Регулярные выражения в Python».

Для решения задачи будем использовать функцию re.findall(), которая ищет все вхождения шаблона в любом месте строки. Для начала вернем каждый символ исходной строки с помощью символа точки (.):

import re string = "Регулярные выражения в Python" result = re.findall(r'.', string) print(result) >>> ['Р', 'е', 'г', 'у', 'л', 'я', 'р', 'н', 'ы', 'е', ' ', 'в', 'ы', 'р', 'а', 'ж', 'е', 'н', 'и', 'я', ' ', 'в', ' ', 'P', 'y', 't', 'h', 'o', 'n']

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

import re string = "Регулярные выражения в Python" result = re.findall(r'\w', string) print(result) >>> ['Р', 'е', 'г', 'у', 'л', 'я', 'р', 'н', 'ы', 'е', 'в', 'ы', 'р', 'а', 'ж', 'е', 'н', 'и', 'я', 'в', 'P', 'y', 't', 'h', 'o', 'n']

Мы избавились от пробелов и теперь попробуем объединить буквы в слова с помощью символа +:

import re string = "Регулярные выражения в Python" result = re.findall(r'\w+', string) print(result) >>> ['Регулярные', 'выражения', 'в', 'Python']

Теперь осталось выбрать только первое слово с помощью символа ^:

import re string = "Регулярные выражения в Python" result = re.findall(r'^\w+', string) print(result) >>> ['Регулярные']

Задача 2

Вернуть последнее слово из строки «Регулярные выражения в Python».

Эта задача тесно связана с прошлой. Мы уже научились получать каждое слово из фразы и возвращать только первое. Для того чтобы вернуть последнее слово, следует заменить символ ^ в начале регулярного выражения на $ в конце:

import re string = "Регулярные выражения в Python" result = re.findall(r'\w+$', string) print(result) >>> ['Python']

Задача 3

Проверить формат телефонного номера. Номер должен состоять из 11 знаков и начинаться с 7 или 8. На вход подается список телефонных номеров. Если номер корректный, то следует вернуть Correct, иначе — Incorrect.

Сперва составим регулярное выражение. В самом начале должна идти цифра 7 или 8. Запишем это в виде [78]. После этого следуют 10 любых цифр от 0 до 9 — [0-9]. Если записать это все вместе, то получится [78][0-9].

Теперь воспользуемся условием if. Если запись номера телефона будет соответствовать шаблону и содержать в себе 11 символов, то будем печатать Correct, иначе — Incorrect. По всему списку номеров пройдемся с помощью цикла for:

import re phone_numbers = ['89154167654', '38764356622', '79853452190', '891678645432', '8916657b589'] for number in phone_numbers: if re.match(r'[78][0-9]', number) and len(number) == 11: print('Correct') else: print('Incorrect') >>> Correct >>> Incorrect >>> Correct >>> Incorrect >>> Incorrect

Задача 4

В офисе сотрудники могут забронировать себе любое рабочее место на целый день. В системе это записывается в виде строки в формате Фамилия_сотрудника Номер_рабочего_места Дата. Номер рабочего места всегда представляет собой трехзначное число, а дата записывается в формате ДД-ММ-ГГГГ. Необходимо написать регулярное выражение, которое вернет даты бронирования рабочих мест.

Для решения задачи надо сперва извлечь все числа из списка. Сделать это можно с помощью \d:

import re booking = 'Иванов 023 14-08-2023, Петров 114 15-08-2023, Семенов 001 20-08-2023, Кутузов 001 01-09-2023' result = re.findall(r'\d', booking) print(result) >>> ['0', '2', '3', '1', '4', '0', '8', '2', '0', '2', '3'. ]

На выходе мы получили абсолютно все цифры из списка, но мы знаем точный паттерн, по которому задается дата, — ДД-ММ-ГГГГ. Сперва идут двузначное число дня, потом двузначное число месяца и в самом конце четырехзначное число года. В качестве разделителей используется дефис. Все это можно описать в виде следующего регулярного выражения:

import re booking = 'Иванов 023 14-08-2023, Петров 114 15-08-2023, Семенов 001 20-08-2023, Кутузов 001 01-09-2023' result = re.findall(r'\d-\d-\d', booking) print(result) >>> ['14-08-2023', '15-08-2023', '20-08-2023', '01-09-2023']

Задача 5

В России для регистрации машин используют принятый стандарт регистрационных знаков. Для частных автомобилей он состоит из серии, самого номера и кода региона регистрации. Запись автомобильного номера выглядит так: С065МК777. На вход программы подается список автомобильных номеров. Надо проверить соответствие их записи с государственным стандартом.

Ввод Вывод
В443РХ777
АА545Р750
Е454АЕ150
М709РО96
В45РАВ77
У822НО02
✅ — В443РХ777
❌ — АА545Р750
✅ — Е454АЕ150
✅ — М709РО96
❌ — В45РАВ77
✅ — У822НО02

Для записи серии номера используются заглавные буквы русского алфавита, у которых есть аналоги в латинице — А, В, Е, К, М, Н, О, Р, С, Т, У и Х. Номер региона записывается двумя или тремя цифрами. Будем проверять наличие последовательности из одной буквы, трех цифр, двух букв и от двух до трех цифр.

По всему списку пройдемся с помощью цикла for, а проверять соответствие и печатать результат будем с помощью условия if:

import re numbers = 'В443РХ777', 'АА545Р750', 'Е454АЕ150', 'М709РО96', 'В45РАВ77', 'У822НО02' for number in numbers: if re.findall(r'[АВЕКМНОРСТУХ]\d[АВЕКМНОРСТУХ]\d', number): print('✅ — ' + number) else: print('❌ — ' + number) .

Где практиковаться с регулярными выражениями

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

  • Regex Learn — интерактивный курс по регулярным выражениям. Авторы предлагают пошагово изучить тему с нуля. На платформе есть базовый курс из 56 уроков и еще один — по применению регулярных выражений в SEO из 17 уроков из 9 видеороликов. Оба курса бесплатные, но доступны только на английском языке.

курса Regex Learn

  • Regex One — еще один пошаговый курс, освещающий все аспекты работы с регулярными выражениями. Во время прохождения придется решать много задач и составлять сложные «регулярки».

упражнения по регулярным выражениям Python Regex One

  • Codewars — на платформе собраны задачи по языкам программирования, но среди них встречаются и регулярные выражения. Можно отфильтровать коллекцию задач по темам, чтобы решать только нужные.

Интерфейс платформы с задачами Codewars

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

Список популярных онлайн-редакторов регулярных выражений:

Итог

  • Регулярные выражения в Python — мощный инструмент для работы с текстом и строками.
  • С помощью регулярных выражений можно проверять валидность адресов, парсить документы и искать данные в тексте.
  • Шаблоны позволяют тонко настроить поиск по фрагментам текста.
  • В теме регулярных выражений мало теории, и успех освоения технологии зависит от большого количества практики.
  • Регулярные выражения поддерживаются практически во всех языках программирования, поэтому, освоив их в Python, можно применять и в других популярных языках.
  • Для закрепления материала важно последовательное изучение. Не стоит после решения задач по поиску дат в тексте переходить к парсингу HTML-файлов.

Python-разработчик

Освойте Python с нуля. Подготовим к трудоустройству: дадим много практики, реальные проекты для портфолио, поможем с резюме. Лучшие студенты пройдут стажировки в проектах компаний-партнеров.

Регулярные выражения Python для новичков: что это, зачем и для чего

image

За последние несколько лет машинное обучение, data science и связанные с этими направлениями отрасли очень сильно шагнули вперед. Все больше компаний и просто разработчиков используют Python и JavaScript для работы с данными.

И вот здесь-то нам как раз и нужны регулярные выражения. Парсинг всего текста или его фрагментов с веб-страниц, анализ данных Twitter или подготовка данных для анализа текста — регулярные выражения приходят на помощь.

Кстати, свои советы по некоторым функциям добавил Алексей Некрасов — лидер направления Python в МТС, программный директор направления Python в Skillbox. Чтобы было понятно, где перевод, а где — комментарии, последние мы выделим цитатой.

Зачем нужны регулярные выражения?

  • Определить нужный формат данных, включая телефонный номер или e-mail адрес.
  • Разбивать строки на подстроки.
  • Искать, извлекать и заменять символы.
  • Быстро выполнять нетривиальные операции.

Когда регулярные выражения не нужны? Когда есть аналогичная встроенная в Python функция, а таких немало.

А что там с регулярными выражениями в Python?

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

Что касается самых востребованных методов, предоставляемых модулем, то вот они:

  • re.match()
  • re.search()
  • re.findall()
  • re.split()
  • re.sub()
  • re.compile()

re.match(pattern, string)

Метод предназначен для поиска по заданному шаблону в начале строки. Так, если вызвать метод match() на строке «AV Analytics AV» с шаблоном «AV», то его получится успешно завершить.

import re result = re.match(r'AV', 'AV Analytics Vidhya AV') print(result) Результат:

Здесь мы нашли искомую подстроку. Для вывода ее содержимого используется метод group(). При этом используется «r» перед строкой шаблона, чтобы показать, что это raw-строка в Python.

result = re.match(r'AV', 'AV Analytics Vidhya AV') print(result.group(0)) Результат: AV

Окей, теперь давайте попробуем найти «Analythics» в этой же строке. У нас ничего не получится, поскольку строка начинается на «AV», метод возвращает none:

result = re.match(r'Analytics', 'AV Analytics Vidhya AV') print(result) Результат: None

Методы start() и end() используются для того, чтобы узнать начальную и конечную позицию найденной строки.

result = re.match(r'AV', 'AV Analytics Vidhya AV') print(result.start()) print(result.end()) Результат: 0 2

Все эти методы крайне полезны в ходе работы со строками.

re.search(pattern, string)

Этот метод похож на match(), но его отличие в том, что ищет он не только в начале строки. Так, search() возвращает объект, если мы пробуем найти «Analythics».

result = re.search(r'Analytics', 'AV Analytics Vidhya AV') print(result.group(0)) Результат: Analytics

Что касается метода search (), то он ищет по всей строке, возвращая, впрочем, лишь первое найденное совпадение.

re.findall(pattern, string)

Здесь у нас возврат всех найденных совпадений. Так, у метода findall() нет никаких ограничений на поиск в начале или конце строки. Например, если искать «AV» в строке, то мы получим возврат всех вхождений «AV». Для поиска рекомендуется использовать как раз этот метод, поскольку он умеет работать как re.search(), так и как re.match().

result = re.findall(r'AV', 'AV Analytics Vidhya AV') print(result) Результат: ['AV', 'AV']

re.split(pattern, string, [maxsplit=0])

Этот метод разделяет строку по заданному шаблону.

result = re.split(r'y', 'Analytics') print(result) Результат: ['Anal', 'tics']

В указанном примере слово «Analythics» разделено по букве «y». Метод split() здесь принимает и аргумент maxsplit со значением по умолчанию, равным 0. Таким образом он разделяет строку столько раз, сколько это возможно. Правда, если указать этот аргумент, то разделение не может быть выполнено более указанного количества раз. Вот несколько примеров:

result = re.split(r'i', 'Analytics Vidhya') print(result) Результат: ['Analyt', 'cs V', 'dhya'] # все возможные участки. result = re.split(r'i', 'Analytics Vidhya', maxsplit=1) print(result) Результат: ['Analyt', 'cs Vidhya']

Здесь параметр maxsplit установлен равным 1, в результате чего строка разделена на две части вместо трех.

re.sub(pattern, repl, string)

Помогает найти шаблон в строке, заменяя на указанную подстроку. Если же искомое не найдено, то строка остается неизменной.

result = re.sub(r'India', 'the World', 'AV is largest Analytics community of India') print(result) Результат: 'AV is largest Analytics community of the World'

re.compile(pattern, repl, string)

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

pattern = re.compile('AV') result = pattern.findall('AV Analytics Vidhya AV') print(result) result2 = pattern.findall('AV is largest analytics community of India') print(result2) Результат: ['AV', 'AV'] ['AV']

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

  • . Один любой символ, кроме новой строки \n.
  • ? 0 или 1 вхождение шаблона слева
  • + 1 и более вхождений шаблона слева
  • * 0 и более вхождений шаблона слева
  • \w Любая цифра или буква (\W — все, кроме буквы или цифры)
  • \d Любая цифра [0-9] (\D — все, кроме цифры)
  • \s Любой пробельный символ (\S — любой непробельный символ)
  • \b Граница слова
  • [..] Один из символов в скобках ([^..] — любой символ, кроме тех, что в скобках)
  • \ Экранирование специальных символов (\. означает точку или \+ — знак «плюс»)
  • ^ и $ Начало и конец строки соответственно
  • От n до m вхождений ( — от 0 до m)
  • a|b Соответствует a или b
  • () Группирует выражение и возвращает найденный текст
  • \t, \n, \r Символ табуляции, новой строки и возврата каретки соответственно

Несколько примеров использования регулярных выражений

Пример 1. Возвращение первого слова из строки

Давайте сначала попробуем получить каждый символ с использованием (.)

result = re.findall(r'.', 'AV is largest Analytics community of India') print(result) Результат: ['A', 'V', ' ', 'i', 's', ' ', 'l', 'a', 'r', 'g', 'e', 's', 't', ' ', 'A', 'n', 'a', 'l', 'y', 't', 'i', 'c', 's', ' ', 'c', 'o', 'm', 'm', 'u', 'n', 'i', 't', 'y', ' ', 'o', 'f', ' ', 'I', 'n', 'd', 'i', 'a']

Теперь сделаем то же самое, но чтобы в конечный результат не попал пробел, используем \w вместо (.)

result = re.findall(r'\w', 'AV is largest Analytics community of India') print(result) Результат: ['A', 'V', 'i', 's', 'l', 'a', 'r', 'g', 'e', 's', 't', 'A', 'n', 'a', 'l', 'y', 't', 'i', 'c', 's', 'c', 'o', 'm', 'm', 'u', 'n', 'i', 't', 'y', 'o', 'f', 'I', 'n', 'd', 'i', 'a']

Ну а теперь проделаем аналогичную операцию с каждым словом. Используем при этом * или +.

result = re.findall(r'\w*', 'AV is largest Analytics community of India') print(result) Результат: ['AV', '', 'is', '', 'largest', '', 'Analytics', '', 'community', '', 'of', '', 'India', '']

Но и здесь в результате оказались пробелы. Причина — * означает «ноль или более символов». «+» поможет нам их убрать.

result = re.findall(r'\w+', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']

Теперь давайте извлечем первое слово с использованием
^:

result = re.findall(r'^\w+', 'AV is largest Analytics community of India') print(result) Результат: ['AV']

А вот если использовать $ вместо ^, то получаем последнее слово, а не первое:

result = re.findall(r'\w+$', 'AV is largest Analytics community of India') print(result) Результат: [‘India’] 

Пример 2. Возвращаем два символа каждого слова

Здесь, как и выше, есть несколько вариантов. В первом случае, используя \w, извлекаем два последовательных символа, кроме тех, что с пробелами, из каждого слова:

result = re.findall(r'\w\w', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'la', 'rg', 'es', 'An', 'al', 'yt', 'ic', 'co', 'mm', 'un', 'it', 'of', 'In', 'di']

Теперь пробуем извлечь два последовательных символа с использованием символа границы слова (\b):

result = re.findall(r'\b\w.', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'la', 'An', 'co', 'of', 'In']

Пример 3. Возвращение доменов из списка адресов электронной почты.

На первом этапе возвращаем все символы после @:

result = re.findall(r'@\w+', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz') print(result) Результат: ['@gmail', '@test', '@analyticsvidhya', '@rest']

В итоге части «.com», «.in» и т. д. не попадают в результат. Чтобы исправить это, нужно поменять код:

result = re.findall(r'@\w+.\w+', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz') print(result) Результат: ['@gmail.com', '@test.in', '@analyticsvidhya.com', '@rest.biz']

Второй вариант решения той же проблемы — извлечение лишь домена верхнего уровня с использованием «()»:

result = re.findall(r'@\w+.(\w+)', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz') print(result) Результат: ['com', 'in', 'com', 'biz']

Пример 4. Получение даты из строки

Для этого необходимо использовать \d

result = re.findall(r'\d-\d-\d', 'Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009') print(result) Результат: ['12-05-2007', '11-11-2011', '12-01-2009']

Для того, чтобы извлечь только год, помогают скобки:

result = re.findall(r'\d-\d-(\d)', 'Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009') print(result) Результат: ['2007', '2011', '2009']

Пример 5. Извлечение слов, начинающихся на гласную

На первом этапе нужно вернуть все слова:

result = re.findall(r'\w+', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']

После этого лишь те, что начинаются на определенные буквы, с использованием «[]»:

result = re.findall(r'[aeiouAEIOU]\w+', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'argest', 'Analytics', 'ommunity', 'of', 'India']

В полученном примере есть два укороченные слова, это «argest» и «ommunity». Для того, чтобы убрать их, нужно воспользоваться \b, что необходимо для обозначения границы слова:

result = re.findall(r'\b[aeiouAEIOU]\w+', 'AV is largest Analytics community of India') print(result) Результат: ['AV', 'is', 'Analytics', 'of', 'India']

Кроме того, можно использовать и ^ внутри квадратных скобок, что помогает инвертировать группы:

result = re.findall(r'\b[^aeiouAEIOU]\w+', 'AV is largest Analytics community of India') print(result) Результат: [' is', ' largest', ' Analytics', ' community', ' of', ' India']

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

result = re.findall(r'\b[^aeiouAEIOU ]\w+', 'AV is largest Analytics community of India') print(result) Результат: ['largest', 'community']

Пример 6. Проверка формата телефонного номера

В нашем примере длина номера — 10 знаков, начинается он с 8 или 9. Для проверки списка телефонных номеров используем:

li = ['9999999999', '999999-999', '99999x9999'] for val in li: if re.match(r'[8-9][0-9]', val) and len(val) == 10: print('yes') else: print('no') Результат: yes no no

Пример 7. Разбиваем строку по нескольким разделителям

Здесь у нас несколько вариантов решения. Вот первое:

line = 'asdf fjdk;afed,fjek,asdf,foo' # String has multiple delimiters (";",","," "). result = re.split(r'[;,\s]', line) print(result) Результат: ['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']

Кроме того, можно использовать метод re.sub() для замены всех разделителей пробелами:

line = 'asdf fjdk;afed,fjek,asdf,foo' result = re.sub(r'[;,\s]', ' ', line) print(result) Результат: asdf fjdk afed fjek asdf foo

Пример 8. Извлекаем данные из html-файла

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

Пример файла

1 Noah Emma

2 Liam Olivia

3 Mason Sophia

4 Jacob Isabella

5 William Ava

6 Ethan Mia

7 Michael Emily

Для того, чтобы решить эту задачу, выполняем следующую операцию:

result=re.findall(r'\w+\s(\w+)\s(\w+)',str) print(result) Output: [('Noah', 'Emma'), ('Liam', 'Olivia'), ('Mason', 'Sophia'), ('Jacob', 'Isabella'), ('William', 'Ava'), ('Ethan', 'Mia'), ('Michael', 'Emily')]

При написании любых regex в коде придерживаться следующих правил:

  • Используйте re.compile для любых более менее сложных и длинных регулярных выражениях. А также избегайте многократного вызова re.compile на один и тот же regex.
  • Пишите подробные регулярные выражения используя дополнительный аргумент re.VERBOSE. При re.compile используйте флаг re.VERBOSE пишите regex в несколько строк с комментариями о том что происходит. Смотрите документацию по ссылкам тут и тут.
pattern = '^M(CM|CD|D?C)(XC|XL|L?X)(IX|IV|V?I)$' re.search(pattern, 'MDLV')
pattern = """ ^ # beginning of string M # thousands - 0 to 3 Ms (CM|CD|D?C) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs), # or 500-800 (D, followed by 0 to 3 Cs) (XC|XL|L?X) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs), # or 50-80 (L, followed by 0 to 3 Xs) (IX|IV|V?I) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is), # or 5-8 (V, followed by 0 to 3 Is) $ # end of string """ re.search(pattern, 'M’, re.VERBOSE)

Используйте named capture group для всех capture group, если их больше чем одна (?P. ). (даже если одна capture, тоже лучше использовать).
regex101.com отличный сайт для дебага и проверки regex

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

  • python
  • регулярные выражения
  • программирование
  • Блог компании Skillbox
  • Python
  • Программирование
  • Учебный процесс в IT

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *