Import re python что значит

Использование регулярных выражений в Python

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

Новое в Python 3.11: Механизм сопоставления регулярных выражений модуля re был частично переработан и теперь использует вычисляемые переходы (или «поточный код«) на поддерживаемых платформах. В результате Python 3.11 выполняет тесты регулярных выражений pyperformance на 10% быстрее, чем Python 3.10.

Шаблоны регулярных выражений и строки для поиска могут быть как Unicode strings, так и 8-битными строками . Однако строки Unicode и 8-битные строки не могут быть смешаны. То есть вы не можете сопоставить строку Unicode с байтовым шаблоном регулярного выражения или наоборот. Аналогично, при замене на основе регулярного выражения строка замены должна быть того же типа, что и регулярное выражение и строка поиска.

Регулярные выражения используют символ обратной косой черты ‘\’ , чтобы указать специальные формы или разрешить использование специальных символов, используемых в шаблонах поиска без вызова их специального значения. Это противоречит использованию в Python одного и того же символа для той же цели в строковых литералах. Например, чтобы сопоставить обратную косую черту литерала ‘\’ , может потребоваться записать ‘\\\\’ как строку шаблона поиска, потому что регулярное выражение должно быть \\ , и каждая обратная косая черта должна быть выражена как \\ внутри обычного строкового литерала Python.

Решение заключается в использовании необработанной строковой нотации Python для шаблонов регулярных выражений. Обратная косая черта не обрабатывается особым образом в строковом литерале с префиксом ‘r’ . Так что r»\n» это двухсимвольная строка, содержащая ‘\’ и ‘n’ , в то время как «\n» односимвольная строка, содержащая новую строку. Обычно шаблоны поиска будут выражаться в коде Python с использованием этой необработанной строковой записи.

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

Синтаксис регулярных выражений в Python

Регулярные выражения могут быть объединены для формирования новых регулярных выражений; если A и B оба являются регулярными выражениями, то AB также является регулярным выражением. Большинство обычных символов, таких как ‘A’, ‘a’или ‘0’, являются простейшими регулярными выражениями; они просто соот

Функция compile() модуля re в Python

Функция compile() модуля re компилирует шаблон регулярного выражения pattern в объект регулярного выражения, который может быть использован для поиска совпадений

Флаги, используемые в функции re.compile()

Флаги, используемые для компиляции регулярного выражения.

Функция search() модуля re в Python

Функция search() модуля re сканирует строку string в поисках первого совпадения с шаблоном pattern регулярного выражения и возвращает соответствующий объект соответствия

Функция match() модуля re в Python

Функция match() модуля re вернуть соответствующий объект сопоставления, если ноль или более символов в начале строки string соответствуют шаблону регулярного выражения pattern.

Функция fullmatch() модуля re в Python

Функция fullmatch() модуля re вернет объект сопоставления, если вся строка string соответствует шаблону регулярного выражения pattern.

Функция finditer() модуля re в Python

Функция finditer() модуля re возвращает итератор объектов сопоставления по всем неперекрывающимся совпадениям для шаблона регулярного выражения в строке.

Функция split() модуля re в Python

Функция `split()` модуля `re` делит строку по появлению шаблона регулярного выражения `pattern` и возвращает список получившихся подстрок.

Функция findall() модуля re в Python

Функция findall() модуля re возвращает все неперекрывающиеся совпадения шаблона pattern в строке string в виде списка строк. Строка сканируется слева направо, и совпадения возвращаются в найденном порядке.

Функция sub() модуля re в Python

Функция sub() модуля re возвращает строку, полученную путем замены крайнего левого неперекрывающегося вхождения шаблона регулярного выражения pattern в строке string на строку замены repl. Если шаблон регулярного выражения не найден, строка возвращается без изменений.

Функция subn() модуля re в Python

Функция subn() модуля re выполняет ту же операцию, что и функция sub(), но возвращает кортеж (new_string, number_of_subs_made)

Функция escape() модуля re в Python

Функция `escape()` модуля `re` выполняет экранирование специальных символов в шаблоне. Это полезно, если требуется сопоставить произвольную строку литерала, которая может содержать метасимволы регулярных выражений

Функция purge() модуля re в Python

Функция `purge()` модуля `re` очищает кэш от регулярных выражений.

Исключение error() модуля re в Python

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

Объект регулярного выражения Pattern модуля re в Python

Объект регулярного выражения Pattern получается в результате компиляции шаблона регулярного выражения. Скомпилированные объекты регулярных выражений поддерживают рассмотренные ниже методы и атрибуты.

Объект совпадения с шаблоном Match модуля re в Python

Объект сопоставления регулярного выражения со строкой всегда имеет логическое значение True. Можно проверить, было ли совпадение, с помощью простого утверждения if. else. Объекты сопоставления поддерживают методы и атрибуты.

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Синтаксис регулярных выражений
• Функция compile() модуля re
• Флаги, используемые в функции re.compile()
• Функция search() модуля re
• Функция match() модуля re
• Функция fullmatch() модуля re
• Функция finditer() модуля re
• Функция split() модуля re
• Функция findall() модуля re
• Функция sub() модуля re
• Функция subn() модуля re
• Функция escape() модуля re
• Функция purge() модуля re
• Исключение error() модуля re
• Объект регулярного выражения Pattern модуля re
• Объект совпадения с шаблоном Match модуля re

Python RegEx: практическое применение регулярок

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

Рассмотрим регулярные выражения в Python, начиная синтаксисом и заканчивая примерами использования.

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

1. Основы регулярных выражений
2. Регулярные выражения в Python
3. Задачи

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

Регулярками в Python называются шаблоны, которые используются для поиска соответствующего фрагмента текста и сопоставления символов.

Грубо говоря, у нас есть input-поле, в которое должен вводиться email-адрес. Но пока мы не зададим проверку валидности введённого email-адреса, в этой строке может оказаться совершенно любой набор символов, а нам это не нужно.

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

r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$' 

По сути, наш шаблон — это набор символов, который проверяет строку на соответствие заданному правилу. Давайте разберёмся, как это работает.

Синтаксис RegEx

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

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

• \d — соответствует любой одной цифре и заменяет собой выражение [0-9];
• \D — исключает все цифры и заменяет [^0-9];
• \w — заменяет любую цифру, букву, а также знак нижнего подчёркивания;
• \W — любой символ кроме латиницы, цифр или нижнего подчёркивания;
• \s — соответствует любому пробельному символу;
• \S — описывает любой непробельный символ.

Для чего используются регулярные выражения

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

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

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

Хотите узнать больше? Обратите внимание на статью о регулярках для новичков.

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

В Python для работы с регулярками есть модуль re . Его нужно просто импортировать:

import re 

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

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

Рассмотрим каждый из них подробнее.

Разработка на Python с нуля: роадмап программиста

re.match(pattern, string)

Этот метод ищет по заданному шаблону в начале строки. Например, если мы вызовем метод match() на строке «AV Analytics AV» с шаблоном «AV», то он завершится успешно. Но если мы будем искать «Analytics», то результат будет отрицательный:

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

Искомая подстрока найдена. Чтобы вывести её содержимое, применим метод group() (мы используем «r» перед строкой шаблона, чтобы показать, что это «сырая» строка в Python):

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

Теперь попробуем найти «Analytics» в данной строке. Поскольку строка начинается на «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() вернёт объект, если мы попытаемся найти «Analytics»:

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

Метод search() ищет по всей строке, но возвращает только первое найденное совпадение.

re.findall(pattern, string)

Возвращает список всех найденных совпадений. У метода findall() нет ограничений на поиск в начале или конце строки. Если мы будем искать «AV» в нашей строке, он вернет все вхождения «AV». Для поиска рекомендуется использовать именно findall() , так как он может работать и как 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'] 

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

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'] 

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

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Больше информации по специальным символам можно найти в документации для регулярных выражений в Python 3.

Перейдём к практическому применению Python регулярных выражений и рассмотрим примеры.

Задачи

Вернуть первое слово из строки

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

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’] 

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

Вариант 1: используя \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'] 

Вариант 2: вытащить два последовательных символа, используя символ границы слова ( \b ):

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

Вернуть домены из списка email-адресов

Сначала вернём все символы после «@»:

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'] 

Извлечь дату из строки

Используем \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'] 

Задачи по Python для начинающих от Tproger и GeekBrains

Извлечь слова, начинающиеся на гласную

Для начала вернем все слова:

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'] 

Проверить формат телефонного номера

Номер должен быть длиной 10 знаков и начинаться с 8 или 9. Есть список телефонных номеров, и нужно проверить их, используя регулярки в Python:

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 

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

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 

Извлечь информацию из html-файла

Допустим, нужно извлечь информацию из html-файла, заключенную между

и

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

Пример содержимого html-файла:

1NoahEmma2LiamOlivia3MasonSophia4JacobIsabella5WilliamAva6EthanMia7MichaelEmily 

С помощью регулярных выражений в Python это можно решить так (если поместить содержимое файла в переменную test_str ):

result = re.findall(r'\d([A-Z][A-Za-z]+)([A-Z][A-Za-z]+)', test_str) print result Результат: [('Noah', 'Emma'), ('Liam', 'Olivia'), ('Mason', 'Sophia'), ('Jacob', 'Isabella'), ('William', 'Ava'), ('Ethan', 'Mia'), ('Michael', 'Emily')] 

Следите за новыми постами по любимым темам

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

re — Операції регулярних виразів¶

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

І шаблони, і рядки для пошуку можуть бути рядками Unicode ( str ), а також 8-бітовими рядками ( bytes ). Однак рядки Unicode та 8-бітові рядки не можна змішувати: тобто ви не можете зіставити рядок Unicode з шаблоном байтів або навпаки; так само, коли запитується заміна, рядок заміни має бути того самого типу, що й шаблон, і рядок пошуку.

Regular expressions use the backslash character ( ‘\’ ) to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write ‘\\\\’ as the pattern string, because the regular expression must be \\ , and each backslash must be expressed as \\ inside a regular Python string literal. Also, please note that any invalid escape sequences in Python’s usage of the backslash in string literals now generate a SyntaxWarning and in the future this will become a SyntaxError . This behaviour will happen even if it is a valid escape sequence for a regular expression.

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

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

Сторонній модуль regex, який має API, сумісний із модулем стандартної бібліотеки re , але пропонує додаткові функції та більш повну підтримку Unicode.

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

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

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

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

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

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

Repetition operators or quantifiers ( * , + , ? , , etc) cannot be directly nested. This avoids ambiguity with the non-greedy modifier suffix ? , and with other modifiers in other implementations. To apply a second repetition to an inner repetition, parentheses may be used. For example, the expression (?:a)* matches any multiple of six ‘a’ characters.

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

(Точка.) У режимі за замовчуванням це відповідає будь-якому символу, крім символу нового рядка. Якщо вказано прапорець DOTALL , він відповідає будь-якому символу, включаючи новий рядок.

(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“.

Like the ‘*’ , ‘+’ , and ‘?’ quantifiers, those where ‘+’ is appended also match as many times as possible. However, unlike the true greedy quantifiers, these do not allow back-tracking when the expression following it fails to match. These are known as possessive quantifiers. For example, a*a will match ‘aaaa’ because the a* will match all 4 ‘a’ s, but, when the final ‘a’ is encountered, the expression is backtracked so that in the end the a* ends up matching 3 ‘a’ s total, and the fourth ‘a’ is matched by the final ‘a’ . However, when a*+a is used to match ‘aaaa’ , the a*+ will match all 4 ‘a’ , but when the final ‘a’ fails to find any more characters to match, the expression cannot be backtracked and will thus fail to match. x*+ , x++ and x?+ are equivalent to (?>x*) , (?>x+) and (?>x?) correspondingly.

Нове в версії 3.11.

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

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

Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as few repetitions as possible. This is the non-greedy version of the previous quantifier. For example, on the 6-character string ‘aaaaaa’ , a will match 5 ‘a’ characters, while a? will only match 3 characters.

Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible without establishing any backtracking points. This is the possessive version of the quantifier above. For example, on the 6-character string ‘aaaaaa’ , a+aa attempt to match 5 ‘a’ characters, then, requiring 2 more ‘a’ s, will need more characters than available and thus fail, while aaa will match with a capturing 5, then 4 ‘a’ s by backtracking and then the final 2 ‘a’ s are matched by the final aa in the pattern. x+ is equivalent to (?>x) .

Нове в версії 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-] ), він відповідатиме літералу ‘-‘ .
• Спеціальні символи втрачають своє особливе значення в наборах. Наприклад, [(+*)] відповідатиме будь-якому з літеральних символів ‘(‘ , ‘+’ , ‘*’ або ‘)’ .

• Класи символів, такі як \w або \S (визначені нижче), також приймаються всередині набору, хоча символи, яким вони відповідають, залежать від режиму ASCII або LOCALE є чинним.

• Символи, які не входять до діапазону, можуть бути зіставлені шляхом complementing набору. Якщо першим символом набору є ‘^’ , усі символи, яких не в наборі, будуть зіставлені. Наприклад, [^5] відповідатиме будь-якому символу, крім ‘5» , а [^^] відповідатиме будь-якому символу, крім ‘^’ . ^ не має особливого значення, якщо це не перший символ у наборі.
• To match a literal ‘]’ inside a set, precede it with a backslash, or place it at the beginning of the set. For example, both [()[\]<>] and []()[<>] will match a right bracket, as well as left bracket, braces, and parentheses.

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

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

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

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

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

(Одна або кілька літер із набору ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ .) Група відповідає порожньому рядку; літери встановлюють відповідні позначки: re.A (відповідність лише ASCII), re.I (ігнорувати регістр), re.L (залежно від локалі), re.M (багаторядковий), re.S (крапка відповідає всім), re.U (відповідність Unicode) і re.X (дослівний ), для всього регулярного виразу. (Прапори описано в Зміст модуля .) Це корисно, якщо ви бажаєте включити прапори як частину регулярного виразу замість передачі аргументу flag до функція re.compile() . Прапори слід використовувати першими в рядку виразу.

Змінено в версії 3.11: This construction can only be used at the start of the expression.

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

(Нуль або більше літер із набору ‘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 (дослівно) для частини виразу. (Прапорці описані в Зміст модуля .)

Літери ‘a’ , ‘L’ і ‘u’ є взаємовиключними, коли використовуються як вбудовані прапорці, тому їх не можна поєднувати або слідувати за ‘-‘ . Натомість, коли один із них з’являється у вбудованій групі, він замінює режим відповідності в охоплюючій групі. У шаблонах Unicode (?a. ) перемикається на відповідність лише ASCII, а (?u. ) перемикається на відповідність Unicode (за замовчуванням). У шаблоні байтів (?L. ) перемикається на відповідність залежно від локалі, а (?a. ) перемикається на відповідність лише ASCII (за замовчуванням). Це перевизначення діє лише для вузької вбудованої групи, а вихідний режим відповідності відновлюється за межами групи.

Нове в версії 3.6.

Змінено в версії 3.7: Літери ‘a’ , ‘L’ і ‘u’ також можна використовувати в групі.

Attempts to match . as if it was a separate regular expression, and if successful, continues to match the rest of the pattern following it. If the subsequent pattern fails to match, the stack can only be unwound to a point before the (?>. ) because once exited, the expression, known as an atomic group, has thrown away all stack points within itself. Thus, (?>.*). would never match anything because first the .* would match all characters possible, then, having nothing left to match, the final . would fail to match. Since there are no stack points saved in the Atomic Group, and there is no stack point before it, the entire expression would thus fail to match.

Нове в версії 3.11.

Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name. Group names must be valid Python identifiers, and in bytes patterns they can only contain bytes in the ASCII range. Each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named.

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

Контекст посилання на групу «цитата»

Способи посилання на нього

за таким самим шаблоном

під час обробки відповідного об’єкта m

• m.group(‘quote’)
• m.end(‘quote’) (і т.д.)

у рядку, переданому в аргумент repl re.sub()

Змінено в версії 3.12: In bytes patterns, group name can only contain bytes in the ASCII range ( b’\x00′ — b’\x7f’ ).

Зворотне посилання на іменовану групу; він відповідає будь-якому тексту, який відповідав попередній групі під назвою 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' 

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

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

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

Змінено в версії 3.12: Group id can only contain ASCII digits. In bytes patterns, group name can only contain bytes in the ASCII range ( b’\x00′ — b’\x7f’ ).

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

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

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

Збігається з порожнім рядком, але лише на початку або в кінці слова. Слово визначається як послідовність символів слова. Зауважте, що формально \b визначається як межа між символом \w і \W (або навпаки), або між \w і початком/ кінець рядка. Це означає, що r’\bfoo\b’ відповідає ‘foo’ , ‘foo.» , ‘(foo)’ , ‘bar foo baz’ , але не ‘foobar’ або ‘foo3’ .

За замовчуванням буквено-цифрові символи Unicode використовуються в шаблонах Unicode, але це можна змінити за допомогою прапорця ASCII . Межі слів визначаються поточною мовою, якщо використовується прапорець LOCALE . Усередині діапазону символів \b представляє символ зворотного пробілу для сумісності з рядковими літералами Python.

Збігається з порожнім рядком, але лише якщо він не на початку або в кінці слова. Це означає, що r’py\B» відповідає ‘python’ , ‘py3’ , ‘py2’ , але не ‘py’ , ‘py.’ або ‘py!’ . \B є прямою протилежністю \b , тому символи слів у шаблонах Unicode є буквено-цифровими символами Unicode або підкресленням, хоча це можна змінити за допомогою прапорця ASCII . Межі слів визначаються поточною мовою, якщо використовується прапорець LOCALE .

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

Відповідає будь-якій десятковій цифрі Unicode (тобто будь-якому символу в категорії символів Unicode [Nd]). Це включає в себе «[0-9]», а також багато інших цифрових символів. Якщо використовується прапорець ASCII , збігається лише [0-9] .

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

Збігається з будь-якою десятковою цифрою; це еквівалентно [0-9] .

Відповідає будь-якому символу, який не є десятковою цифрою. Це протилежність \d . Якщо використовується прапорець ASCII , це стає еквівалентом [^0-9] .

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

Відповідає пробілам Юнікоду (зокрема, [ \t\n\r\f\v] , а також багатьом іншим символам, наприклад нерозривним пробілам, передбаченим правилами типографіки багатьох мов). Якщо використовується прапорець ASCII , збігається лише [ \t\n\r\f\v] .

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

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

Відповідає будь-якому символу, який не є пробілом. Це протилежність \s . Якщо використовується прапорець ASCII , це стає еквівалентом [^ \t\n\r\f\v] .

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

Matches Unicode word characters; this includes alphanumeric characters (as defined by str.isalnum() ) as well as the underscore ( _ ). If the ASCII flag is used, only [a-zA-Z0-9_] is matched.

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

Відповідає символам, які вважаються буквено-цифровими в наборі символів ASCII; це еквівалентно [a-zA-Z0-9_] . Якщо використовується прапорець LOCALE , відповідає символам, які вважаються буквено-цифровими в поточній локалі, і підкресленню.

Відповідає будь-якому символу, який не є символом слова. Це протилежність \w . Якщо використовується прапорець ASCII , це стає еквівалентом [^a-zA-Z0-9_] . Якщо використовується прапорець LOCALE , відповідає символам, які не є ані буквено-цифровими в поточній локалі, ані підкресленням.

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

Most of the escape sequences supported by Python string literals are also accepted by the regular expression parser:

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

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

Екран-послідовності ‘\u’ , ‘\U’ і ‘\N» розпізнаються лише в шаблонах Unicode. У шаблонах байтів це помилки. Невідомі вихідні коди літер ASCII зарезервовано для майбутнього використання та розглядаються як помилки.

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

Змінено в версії 3.3: Було додано керуючі послідовності ‘\u’ і ‘\U’ .

Змінено в версії 3.6: Невідомі вихідні символи, що складаються з ‘\’ і літери ASCII, тепер є помилками.

Змінено в версії 3.8: The ‘\N < name >’ escape sequence has been added. As in string literals, it expands to the named Unicode character (e.g. ‘\N’ ).

Зміст модуля¶

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

Прапори¶

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

class re. RegexFlag ¶

An enum.IntFlag class containing the regex options listed below.

Нове в версії 3.11: — added to __all__

re. A ¶ re. ASCII ¶

Зробіть \w , \W , \b , \B , \d , \D , \s і \S виконує зіставлення тільки ASCII замість повного зіставлення Unicode. Це має значення лише для шаблонів Unicode та ігнорується для шаблонів байтів. Відповідає вбудованому прапору (?a) .

Зауважте, що для зворотної сумісності прапор re.U все ще існує (а також його синонім re.UNICODE і його вбудований аналог (?u) ), але вони зайві. у Python 3, оскільки збіги є Юнікодом за замовчуванням для рядків (і збіги Юнікоду не дозволені для байтів).

Відображення налагоджувальної інформації про скомпільований вираз. Немає відповідного вбудованого прапора.

re. I ¶ re. IGNORECASE ¶

Виконуйте зіставлення без урахування регістру; такі вирази, як [A-Z] також відповідатимуть малим регістрам. Повна відповідність Юнікоду (наприклад, Ü , яка відповідає ü ) також працює, якщо не використовується прапор re.ASCII , щоб вимкнути збіги, відмінні від ASCII. Поточна локаль не змінює ефект цього прапорця, якщо також не використовується прапорець re.LOCALE . Відповідає вбудованому прапору (?i) .

Зауважте, що коли шаблони Unicode [a-z] або [A-Z] використовуються в поєднанні з прапором 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 і відповідність без урахування регістру залежно від поточної мови. Цей прапорець можна використовувати лише з шаблонами байтів. Використання цього прапорця не рекомендується, оскільки механізм локалізації є дуже ненадійним, він обробляє лише одну «культуру» за раз і працює лише з 8-бітними локалізаціями. Зіставлення Unicode вже ввімкнено за замовчуванням у Python 3 для шаблонів Unicode (str), і він здатний обробляти різні локалі/мови. Відповідає вбудованому прапору (?L) .

Змінено в версії 3.6: re.LOCALE можна використовувати лише з шаблонами байтів і несумісний з re.ASCII .

Змінено в версії 3.7: Зкомпільовані регулярні вирази з прапорцем re.LOCALE більше не залежать від локалі під час компіляції. Лише локаль під час зіставлення впливає на результат зіставлення.

re. M ¶ re. MULTILINE ¶

Якщо вказано, символ шаблону ‘^’ збігається на початку рядка та на початку кожного рядка (відразу після кожного нового рядка); і символ шаблону ‘$’ збігається в кінці рядка та в кінці кожного рядка (безпосередньо перед кожним новим рядком). За замовчуванням ‘^’ збігається лише на початку рядка, а ‘$’ лише в кінці рядка та безпосередньо перед символом нового рядка (якщо є) у кінці рядка. Відповідає вбудованому прапору (?m) .

Indicates no flag being applied, the value is 0 . This flag may be used as a default value for a function keyword argument or as a base value that will be conditionally ORed with other flags. Example of use as a default value:

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

Нове в версії 3.11.

re. S ¶ re. DOTALL ¶

Зробіть так, щоб спеціальний символ ‘.’ відповідав будь-якому символу взагалі, включаючи новий рядок; без цього прапорця ‘.’ відповідатиме будь-чому крім нового рядка. Відповідає вбудованому прапору (?s) .

re. U ¶ re. UNICODE ¶

In Python 2, this flag made special sequences include Unicode characters in matches. Since Python 3, Unicode characters are matched by default.

See A for restricting matching on ASCII characters instead.

This flag is only kept for backward compatibility.

re. X ¶ re. VERBOSE ¶

This flag allows you to write regular expressions that look nicer and are more readable by allowing you to visually separate logical sections of the pattern and add comments. Whitespace within the pattern is ignored, except when in a character class, or when preceded by an unescaped backslash, or within tokens like *? , (?: or (?P <. >. For example, (? : and * ? are not allowed. When a line contains a # that is not in a character class and is not preceded by an unescaped backslash, all characters from the leftmost such # through the end of the line are ignored.

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

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

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

Функції¶

re. compile ( pattern , flags = 0 ) ¶

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

Поведінку виразу можна змінити, вказавши значення flags. Значеннями можуть бути будь-які з наведених нижче змінних, об’єднаних за допомогою побітового АБО (оператор | ).

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

result = re.match(pattern, string) 

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

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

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

Scan through string looking for the first location where the regular expression pattern produces a match, and return a corresponding Match . Return None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

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

If zero or more characters at the beginning of string match the regular expression pattern, return a corresponding Match . Return None if the string does not match the pattern; note that this is different from a zero-length match.

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

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

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

If the whole string matches the regular expression pattern, return a corresponding Match . Return None if the string does not match the pattern; note that this is different from a zero-length match.

Нове в версії 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.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9'] 

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

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

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

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

>>> 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', '. ', '', '', ''] 

Змінено в версії 3.1: Додано необов’язковий аргумент flags.

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

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')] 

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

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

Return an iterator yielding Match objects over all non-overlapping matches for the RE pattern in string. The string is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result.

Змінено в версії 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 

If repl is a function, it is called for every non-overlapping occurrence of pattern. The function takes a single Match argument, and returns the replacement string. For example:

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

The pattern may be a string or a Pattern .

Необов’язковий аргумент count — це максимальна кількість шаблонів, які потрібно замінити; count має бути невід’ємним цілим числом. Якщо опущено або дорівнює нулю, усі входження буде замінено. Порожні збіги для шаблону замінюються лише тоді, коли вони не суміжні з попереднім порожнім збігом, тому sub(‘x*’, ‘-‘, ‘abxd’) повертає ‘-a-b—d-‘ .

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

Змінено в версії 3.1: Додано необов’язковий аргумент flags.

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

Змінено в версії 3.6: Невідомі вихідні коди в шаблоні, що складаються з ‘\’ і літери ASCII, тепер є помилками.

Змінено в версії 3.7: Невідомі вихідні символи в repl, які складаються з ‘\’ і літери ASCII, тепер є помилками.

Змінено в версії 3.7: Порожні збіги для шаблону замінюються, якщо вони суміжні з попереднім непорожнім збігом.

Змінено в версії 3.12: Group id can only contain ASCII digits. In bytes replacement strings, group name can only contain bytes in the ASCII range ( b’\x00′ — b’\x7f’ ).

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

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

Змінено в версії 3.1: Додано необов’язковий аргумент flags.

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

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 

Змінено в версії 3.3: Символ «_» більше не екранується.

Змінено в версії 3.7: Екрануються лише символи, які можуть мати спеціальне значення в регулярному виразі. У результаті ‘!’ , ‘»‘ , ‘%’ , «‘» , ‘,’ , ‘/’` `, «’:’ , ‘;’ , ‘ ‘ , ‘@’ і «`» більше не екрануються.

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

Винятки¶

exception re. error ( msg , pattern = None , pos = None ) ¶

Виняток виникає, коли рядок, переданий одній із функцій тут, не є дійсним регулярним виразом (наприклад, він може містити невідповідні дужки) або коли під час компіляції чи зіставлення виникає інша помилка. Ніколи не буде помилкою, якщо рядок не містить збігів для шаблону. Екземпляр помилки має такі додаткові атрибути:

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

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

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

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

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

Змінено в версії 3.5: Додані додаткові атрибути.

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

class re. Pattern ¶

Compiled regular expression object returned by re.compile() .

Змінено в версії 3.9: re.Pattern supports [] to indicate a Unicode (str) or bytes pattern. See Загальний тип псевдоніма .

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

Scan through string looking for the first location where this regular expression produces a match, and return a corresponding Match . Return None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

Необов’язковий другий параметр 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 >>> pattern.search("dog", 1) # No match; search doesn't include the "d" 

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

If zero or more characters at the beginning of string match this regular expression, return a corresponding Match . Return None if the string does not match the pattern; note that this is different from a zero-length match.

Необов’язкові параметри 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».

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

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

If the whole string matches this regular expression, return a corresponding Match . Return None if the string does not match the pattern; note that this is different from a zero-length match.

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

>>> pattern = re.compile(«o[gh]») >>> pattern.fullmatch(«dog») # No match as «o» is not at the start of «dog». >>> pattern.fullmatch(«ogre») # No match as not the full string matches. >>> pattern.fullmatch(«doggie», 1, 3) # Matches within given limits.

Нове в версії 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() , використовуючи скомпільований шаблон.

Прапори відповідності регулярних виразів. Це комбінація прапорів, наданих compile() , будь-яких вбудованих прапорів (. ) у шаблоні та неявних прапорів, таких як UNICODE , якщо шаблон є Рядок Unicode.

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

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

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

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

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

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

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

class re. Match ¶

Match object returned by successful match es and search es.

Змінено в версії 3.9: re.Match supports [] to indicate a Unicode (str) or bytes match. See Загальний тип псевдоніма .

Match. expand ( template ) ¶

Повертає рядок, отриманий заміною зворотної похилої риски в рядку шаблону template, як це робиться методом sub() . Екрани, такі як \n , перетворюються на відповідні символи, а також числові зворотні посилання ( \1 , \2 ) і іменовані зворотні посилання ( \g , \g ) замінюються вмістом відповідної групи.

Змінено в версії 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 . ) , аргументи groupN також можуть бути рядками, що ідентифікують групи за назвою групи. Якщо рядковий аргумент не використовується як ім’я групи в шаблоні, виникає виняток IndexError .

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

>>> m = re.match(r"(?P\w+) (?P\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' 

Named groups are supported as well:

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

Нове в версії 3.6.

Match. groups ( default = None ) ¶

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

>>> 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\w+) (?P\w+)», «Malcolm Reynolds») >>> m.groupdict()
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) . група за замовчуванням дорівнює нулю, весь збіг.

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> valid = re.compile(r"^[a2-9tjqk] $") >>> displaymatch(valid.match("akt5q")) # Valid. "" >>> displaymatch(valid.match("akt5e")) # Invalid. >>> displaymatch(valid.match("akt")) # Invalid. >>> displaymatch(valid.match("727ak")) # Valid. "" 

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

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

Щоб дізнатися, з якої карти складається пара, можна використати метод 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 "", line 1, in re.match(r".*(.).*\1", "718ak").group(1) AttributeError: 'NoneType' object has no attribute 'group' >>> pair.match("354aa").group(1) 'a' 

Імітація scanf()¶

Python does not currently have an equivalent to scanf() . Regular expressions are generally more powerful, though also more verbose, than scanf() format strings. The table below offers some more-or-less equivalent mappings between scanf() format tokens and regular expressions.

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

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

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

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

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

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

Первая идея — проверять строку на наличие символа 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-разработчикоми начать зарабатывать в IT от 80 000 ₽

Функции регулярных выражений в 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 One — еще один пошаговый курс, освещающий все аспекты работы с регулярными выражениями. Во время прохождения придется решать много задач и составлять сложные «регулярки».

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

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

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

Итог

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

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

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