Findall python: Использование регулярных выражений в Python для новичков

Функция findall — Документация Python для сетевых инженеров 3.0

Функция findall():

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

Рассмотрим работу findall на примере вывода команды sh mac
address-table:

In [2]: mac_address_table = open('CAM_table.txt').read()

In [3]: print(mac_address_table)
sw1#sh mac address-table
          Mac Address Table
-------------------------------------------

Vlan    Mac Address       Type        Ports
----    -----------       --------    -----
 100    a1b2.ac10.7000    DYNAMIC     Gi0/1
 200    a0d4.cb20.7000    DYNAMIC     Gi0/2
 300    acb4.cd30.7000    DYNAMIC     Gi0/3
 100    a2bb.ec40.7000    DYNAMIC     Gi0/4
 500    aa4b.c550.7000    DYNAMIC     Gi0/5
 200    a1bb.1c60.7000    DYNAMIC     Gi0/6
 300    aa0b.cc70.7000    DYNAMIC     Gi0/7

Первый пример — регулярное выражение без групп. В этом случае findall
возвращает список строк, которые совпали с регулярным выражением.

Например, с помощью findall можно получить список строк с соответствиями
vlan — mac — interface и избавиться от заголовка в выводе команды:

In [4]: re.findall(r'\d+ +\S+ +\w+ +\S+', mac_address_table)
Out[4]:
['100    a1b2.ac10.7000    DYNAMIC     Gi0/1',
 '200    a0d4.cb20.7000    DYNAMIC     Gi0/2',
 '300    acb4.cd30.7000    DYNAMIC     Gi0/3',
 '100    a2bb.ec40.7000    DYNAMIC     Gi0/4',
 '500    aa4b.c550.7000    DYNAMIC     Gi0/5',
 '200    a1bb.1c60.7000    DYNAMIC     Gi0/6',
 '300    aa0b.cc70.7000    DYNAMIC     Gi0/7']

Обратите внимание, что findall возвращает список строк, а не объект
Match.

Как только в регулярном выражении появляется группа, findall ведет
себя по-другому.
Если в выражении используется одна группа, findall возвращает список
строк, которые совпали с выражением в группе:

In [5]: re.findall(r'\d+ +(\S+) +\w+ +\S+', mac_address_table)
Out[5]:
['a1b2.ac10.7000',
 'a0d4.cb20.7000',
 'acb4.cd30.7000',
 'a2bb.ec40.7000',
 'aa4b.c550.7000',
 'a1bb.1c60.7000',
 'aa0b.cc70.7000']

При этом findall ищет совпадение всей строки, но возвращает результат,
похожий на метод groups() в объекте Match.

Если же групп несколько, findall вернет список кортежей:

In [6]: re.findall(r'(\d+) +(\S+) +\w+ +(\S+)', mac_address_table)
Out[6]:
[('100', 'a1b2.ac10.7000', 'Gi0/1'),
 ('200', 'a0d4.cb20.7000', 'Gi0/2'),
 ('300', 'acb4.cd30.7000', 'Gi0/3'),
 ('100', 'a2bb.ec40.7000', 'Gi0/4'),
 ('500', 'aa4b.c550.7000', 'Gi0/5'),
 ('200', 'a1bb.1c60.7000', 'Gi0/6'),
 ('300', 'aa0b.cc70.7000', 'Gi0/7')]

Если такие особенности работы функции findall мешают получить
необходимый результат, то лучше использовать функцию finditer, но иногда
такое поведение подходит и удобно использовать.

Пример использования findall в разборе лог-файла (файл
parse_log_findall.py):

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

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

import re

Теперь все готово для использования регулярных выражений.

Метод re.search()

Метод re.search() используется для нахождения первого вхождения заданного шаблона в строку.

Синтаксис: re.search(pattern, string, flags[optional])

Метод re.search() принимает на вход шаблон и строку и возвращает объект match в случае успеха, а в противном случае, если шаблон не был найден, возвращает None. Объект match имеет метод group(), который возвращает сам шаблон.

import re
s = "my number is 123"
match = re.search(r'\d\d\d', s)
match
<_sre.SRE_Match object; span=(13, 16), match='123'>
match.group()
'123'

В примере выше мы использовали шаблон \d\d\d. Шаблон \d в регулярных выражениях сравнивает единичные цифры, следовательно \d\d\d будет сравнивать цифры вида 111, 222, 786. Соответственно, цифры вида 12, 1444 будут пропущены.

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

Рассмотрим еще один пример.

import re
s = "tim email is [email protected]"
match = re.search(r'[\w.-]+@[\w.-]+', s)

# Приведенное выше регулярное выражение будет искать e-mail адрес

if match:
    print(match.group())
else:
    print("сравнений не обнаружено")

Ожидаемый результат

[email protected]

Здесь мы использовали шаблон [\w.-]+@[\w.-]+ чтобы найти в строке соответствие с e-mail адресом. В случае успеха метод re.search() возвращает объект match, а уже при помощи метода этого объекта group() можно извлечь хранящийся там текст. В данном примере это [email protected].

Группровка выражений

Группировка выражений позволяет нам извлекать части из нужной строки. Создать группу можно при помощи круглых скобок (). Допустим, мы хотим извлечь отдельно имя пользователя и имя хоста из e-mail адреса, такого как в предыдущем примере. Для этого нам нужно заключить в разные скобки шаблон для имени и шаблон для хоста следующим образом:

match = re.search(r'([\w.-]+)@([\w.-]+)', s)

Обратите внимание: добавление скобок не означает изменение шаблона для поиска соответствия. Наш код по-прежнему ищет полное совпадение с заданным шаблоном. Если поиск увенчается успехом, match.group(1) будет соответствовать содержимому первых круглых скобок, а match.group(2) — содержимому вторых круглых скобок.

import re
s = "tim email is [email protected]"
match = re.search('([\w.-]+)@([\w.-]+)', s)
if match:
    print(match.group()) ## [email protected] (полное сравнение)
    print(match.group(1)) ## tim (the username, первая группа)
    print(match.group(2)) ## somehost (the host, вторая группа)

Функция findall()

Как вы уже знаете, функция re.search() находит только первое вхождение заданного шаблона в строку. А если мы хотим найти все вхождения, в дело вступает функция findall().

Синтаксис: findall(pattern, string, flags=0[optional])

В случае успеха данная функция возвращает список, в котором в виде строк содержатся все искомые вхождения по порядку. Если вхождений нет, то эта функция возвратит пустой список.

import re
s = "Tim's phone numbers are 12345-41521 and 78963-85214"
match = re.findall(r'\d{5}', s)

if match:
    print(match)

Ожидаемый результат:

['12345', '41521', '78963', '85214']

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

import re
s = "Tim's phone numbers are 12345-41521 and 78963-85214"
match = re.findall(r'(\d{5})-(\d{5})', s)
print(match)

for i in match:
    print()
    print(i)
    print("Первая группа", i[0])
    print("Вторая группа", i[1])

Ожидаемый результат:

[('12345', '41521'), ('78963', '85214')]

('12345', '41521')
Первая группа 12345
Вторая группа 41521

('78963', '85214')
Первая группа 78963
Вторая группа 85214

Опциональные флаги

Обе функции, re.search() и re.findall(), могут принимать необязательные параметры — флаги. С их помощью можно слегка изменять поведение функции.

Использование функции re.match()

Функция re.match() очень похожа на функцию re.search(). Различие состоит лишь в том, что функция re.match() начинает поиск сравнений с начала строки.

import re
s = "python tuts"
match = re.match(r'py', s)
match_1 = re.match(r'th', s)
if match:
    print(match.group()) # выведет на экран 'py'
if match_1:
    print(match_1.group()) # не выведет на экран ничего

Того же можно достичь и с функцией re.search(), просто добавив ^ к шаблону сравнения.

import re
s = "python tuts"
match = re.search(r'^py', s)
match_1 = re.search(r'^th', s)
if match:
    print(match.group()) # выведет на экран 'py'
if match_1:
    print(match_1.group()) # не выведет на экран ничего

На этом мы завершаем знакомство с модулем re языка Python.

Модуль Python Re на примерах + задания и шаблоны ~ PythonRu

Регулярные выражения, также называемые 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.

>>> 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_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+ на один пробел .

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

>>> re.findall('[А-ЯЁ]{3}', text)  

>>> re.findall('[а-яА-ЯёЁ]{4,}', text)  
['100', '213', '156']  
['ИНФ', 'МАТ', 'АНГ']  
['Информатика', 'Математика', 'Английский']

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

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

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

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

>>> course_pattern = '([0-9]+)\s*([А-ЯЁ]{3})\s*([а-яА-ЯёЁ]{4,})'  
>>> re.findall(course_pattern, text)  
[('100', 'ИНФ', 'Информатика'), ('213', 'МАТ', 'Математика'), ('156', 'АНГ', 'Английский')]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Повторы

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

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

>>> 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)) 
['01', '2018']

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

>>> text = '01, Янв 2018'  
>>> print(re.findall('\D+', text)) 
[', Янв ']

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

>>> text = '01, Янв 2018'  
>>> print(re.findall('\w+', text)) 
['01', 'Янв', '2018']

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

>>> text = '01, Янв 2018'  
>>> print(re.findall('\W+', text)) 
[', ', ' ']

Только буквы

>>> text = '01, Янв 2018'  
>>> print(re.findall('[а-яА-ЯёЁ]+', text)) 
['Янв']

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

>>> text = '01, Янв 2018'  
>>> print(re.findall('\d{4}', text)) 
['2018'] 
>>> print(re.findall('\d{2,4}', text))  
['01', '2018']

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

>>> print(re.findall(r'Co+l', 'So Cooool')) 
['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']

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

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

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

emails = """[email protected]  
[email protected]  
[email protected]"""  


[('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'

5. Извлеките все текстовые фрагменты между тегами с 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 


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

Ответы

>>> pattern = r'(\w+)@([A-Z0-9]+)\.([A-Z]{2,4})'  
>>> re.findall(pattern, emails, flags=re.IGNORECASE)  
[('zuck26', 'facebook', 'com'), ('page33', 'google', 'com'), ('jeff42', 'amazon', 'com')]

Есть больше шаблонов для извлечения домена и суфикса. Это лишь один из них.

>>> 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, что бы шаблон был не чувствительным к регистру.

>>> import re  
>>> " ".join(re.split('[;,\s_]+', sentence))  
'A very very irregular sentence'  

>>> import re  
>>> def clean_tweet(tweet):  
		tweet = re.sub('http\S+\s*', '', tweet) 
		tweet = re.sub('RT|cc', '', tweet) 
		tweet = re.sub('#\S+', '', tweet) 
		tweet = re.sub('@\S+', '', tweet) 
		tweet = re.sub('[%s]' % re.escape("""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""), '', tweet) 
		tweet = re.sub('\s+', ' ', tweet) 
		return tweet  
	
>>> print(clean_tweet(tweet)) 
'Good advice What I would do differently if I was learning to code today'

>>> 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 и многих других языках программирования. Зачастую регулярные выражения упоминаются как “regex”, “regexp” или просто “RE”, от reuglar expressions. Такие языки как Perl и Ruby фактически поддерживают синтаксис регулярных выражений прямо в собственном языке. Python же поддерживает благодаря библиотеки, которую вам нужно импортировать. Основное использование регулярных выражений – это сопоставление строк. Вы создаете правила сопоставления строк, используя регулярные выражения, после чего вы применяете их в строке, чтобы увидеть, присутствуют ли какие-либо сопоставления. «Язык» регулярных выражений на самом деле весьма короткий, так что вы вряд ли сможете использовать для всех своих нужд при сопоставлении строк. Кроме того, работая с задачами, в которых вы используете регулярные выражения, вы можете заметно усложнить процесс, а лечение багов в таком случае очень трудоемкое. В таких случаях вам нужно просто использовать Python.

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

Согласуемые символы

Когда вам нужно найти символ в строке, в большей части случаев вы можете просто использовать этот символ или строку. Так что, когда нам нужно проверить наличие слова «dog», то мы будем использовать буквы в dog. Конечно, существуют определенные символы, которые заняты регулярными выражениями. Они так же известны как метасимволы. Внизу изложен полный список метасимволов, которые поддерживают регулярные выражения Python:

. ˆ $ * + ? { } [ ] | ( )

Давайте взглянем как они работают. Основная связка метасимволов, с которой вы будете сталкиваться, это квадратные скобки: [ и ]. Они используются для создания «класса символов», который является набором символов, которые вы можете сопоставить. Вы можете отсортировать символы индивидуально, например, так: [xyz]. Это сопоставит любой внесенный в скобки символ. Вы также можете использовать тире для выражения ряда символов, соответственно: [a-g]. В этом примере мы сопоставим одну из букв в ряде между a и g. Фактически для выполнения поиска нам нужно добавить начальный искомый символ и конечный. Чтобы упростить это, мы можем использовать звездочку. Вместо сопоставления *, данный символ указывает регулярному выражению, что предыдущий символ может быть сопоставлен 0 или более раз. Давайте посмотрим на пример, чтобы лучше понять о чем речь:

Этот шаблон регулярного выражения показывает, что мы ищем букву а, ноль или несколько букв из нашего класса, [b-f] и поиск должен закончиться на f. Давайте используем это выражение в Python:

import re
text = ‘abcdfghijk’

parser = re.search(‘a[b-f]*f’)
print(parser.group()) # ‘abcdf’

В общем, это выражение просмотрит всю переданную ей строку, в данном случае это abcdfghijk.
Выражение найдет нашу букву «а» в начале поиска. Затем, в связи с тем, что она имеет класс символа со звездочкой в конце, выражение прочитает остальную часть строки, что бы посмотреть, сопоставима ли она. Если нет, то выражение будет пропускать по одному символу, пытаясь найти совпадения. Вся магия начинается, когда мы вызываем поисковую функцию модуля re. Если мы не найдем совпадение, тогда мы получим None. В противном случае, мы получим объект Match. Чтобы увидеть, как выглядит совпадение, вам нужно вызывать метод group. Существует еще один повторяемый метасимвол, аналогичный *. Этот символ +, который будет сопоставлять один или более раз. Разница с *, который сопоставляет от нуля до более раз незначительна, на первый взгляд.

Символу + необходимо как минимум одно вхождение искомого символа. Последние два повторяемых метасимвола работают несколько иначе. Рассмотрим знак вопроса «?», применение которого выгладит так: “co-?op”. Он будет сопоставлять и “coop” и “co-op”. Последний повторяемый метасимвол это {a,b}, где а и b являются десятичными целыми числами. Это значит, что должно быть не менее «а» повторений, но и не более «b». Вы можете попробовать что-то на подобии этого:

Это очень примитивный пример, но в нем говорится, что мы сопоставим следующие комбинации: xbz, xbbz, xbbbz и xbbbbz, но не xz, так как он не содержит «b».

Следующий метасимвол это ^. Этот символ позволяет нам сопоставить символы которые не находятся в списке нашего класса. Другими словами, он будет дополнять наш класс. Это сработает только в том случае, если мы разместим ^ внутри нашего класса. Если этот символ находится вне класса, тогда мы попытаемся найти совпадения с данным символом. Наглядным примером будет следующий: [ˆa]. Так, выражения будет искать совпадения с любой буквой, кроме «а». Символ ^ также используется как анкор, который обычно используется для совпадений в начале строки.

Существует соответствующий якорь для конце строки – «$». Мы потратим много времени на введение в различные концепты применения регулярных выражений. В следующих параграфах мы углубимся в более подробные примеры кодов.

Поиск сопоставлений шаблонов

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

import re

text = «The ants go marching one by one»

strings = [‘the’, ‘one’]

for string in strings:
match = re.search(string, text)
if match:
print(‘Found «{}» in «{}»‘.format(string, text))
text_pos = match.span()
print(text[match.start():match.end()])
else:
print(‘Did not find «{}»‘.format(string))

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

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Существует несколько других функций, которые нужно прояснить в данном примере. Обратите внимание на то, что мы вызываем span. Это дает нам начальную и конечную позицию совпавшей строки. Если вы выведите text_pos, которому мы назначили span, вы получите кортеж на подобие следующего: (21, 24). В качестве альтернативы вы можете просто вызвать методы сопоставления, что мы и сделаем далее. Мы используем начало и конец для того, чтобы взять начальную и конечную позицию сопоставления, это должны быть два числа, которые мы получаем из span.

Коды поиска

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

• \d соответствует цифре
• \D соответствует не цифре
• \s соответствует пустому полю (пробел)
• \S соответствует заполненному полю
• \w соответствует алфавитно-цифровому значению
• \W соответствует не алфавитно-цифровому значению

Вы можете использовать эти коды внутри класса символа вот так: [\d]. Таким образом, это позволит нам найти любую цифру, находящейся в пределе от 0 до 9. Я настаиваю на том, чтобы вы попробовали остальные коды выхода лично.

Компилирование

Модуль re позволяет вам «компилировать» выражение, которое вы ищите чаще всего. Это также позволит вам превратить выражение в объект SRE_Pattern. Вы можете использовать этот объект в вашей функции поиска в будущем. Давайте используем код из предыдущего примера и изменим его, чтобы использовать компилирование:

import re

text = «The ants go marching one by one»

strings = [‘the’, ‘one’]

for string in strings:
regex = re.compile(string)
match = re.search(regex, text)
if match:
print(‘Found «{}» in «{}»‘.format(string, text))
text_pos = match.span()
print(text[match.start():match.end()])
else:
print(‘Did not find «{}»‘.format(string))

Обратите внимание на то, что здесь мы создаем объект паттерна, вызывая compile в каждой строке нашего списка, и назначаем результат переменной – регулярному выражению. Далее мы передаем это выражение нашей поисковой функции. Остальная часть кода остается неизменной. Основная причина, по которой используют компилирование это сохранить выражение для повторного использования в вашем коде в будущем. В любом случае, компилирование также принимает флаги, которые могут быть использованы для активации различных специальных функций. Мы рассмотрим это далее.
Обратите внимание: когда вы компилируете паттерны, они автоматически кэшируются, так что если вы не особо используете регулярные выражения в своем коде, тогда вам не обязательно сохранять компилированный объект как переменную.

Флаги компиляции

Существует 7 флагов компиляции, которые содержатся в Python 3. Эти флаги могут изменить поведение вашего паттерна. Давайте пройдемся по каждому из них, затем рассмотрим, как их использовать.

re.A / re.ASCII

Флаг ASCII указывает Python сопоставлять против ASCII, вместо использования полного Юникода для сопоставления, в сочетании со следующими кодами: w, W, b, B, d, D, s и S. Также существует флаг re.U / re.UNICODE, который используется в целях обратной совместимости. В любом случае, эти флаги являются излишеством, так как Python выполняет сопоставления в Юникоде в автоматическом режиме.

re.DEBUG

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

re.I / re.IGNORECASE

Если вам нужно выполнить сравнение без учета регистра, тогда этот флаг – то, что вам нужно. Если ваше выражение было [a-z] и вы скомпилировали его при помощи этого флага, то ваш паттерн сопоставит заглавные буквы в том числе. Это также работает для Юникода и не влияет на текущую локаль.

re.L / re.LOCALE

Данный флаг делает коды: w, W, b, B, d, D, s и S зависимыми от нынешней локали. Однако, в документации говорится, что вы не должны зависеть от данного флага, так как механизм локали сам по себе очень ненадежный. Вместо этого, лучше используйте сопоставление Юникода. Далее в документации говорится, что данный флаг имеет смысл использовать только в битовых паттернах.

re.M / re.MULTILINE

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

re.S / re.DOTALL

Этот забавный флаг указывает метасимволу «.» (период) сопоставить любой символ. Без этого флага, данный метасимвол будет сопоставлять все, что угодно, но не новую строку.

re.X / re.VERBOSE

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

Использование флага компиляции

Давайте уделим немного времени, и посмотрим на простой пример, в котором используется флаг компиляции VERBOSE. Неплохой пример – взять обычную электронную почту и использовать поиск регулярных выражений, таких как r’[w.-]+@[w.-]+’ и добавить комментарии, используя флаг VERBOSE. Давайте посмотрим:

re.compile(»’
[\w\.-]+
@
[\w\.-]+’
»’,
re.VERBOSE)

Давайте пройдем дальше и научимся находить множественные совпадения.

Находим множественные совпадения

До этого момента мы научились только находить первое совпадение в строке. Но что если у вас строка, в которой содержится множество совпадений? Давайте посмотрим, как найти одно:

import re

silly_string = «the cat in the hat»
pattern = «the»

match = re.search(pattern, text)
print(match.group()) # ‘the’

Теперь, как вы видите, у нас есть два экземпляра слова the, но нашли мы только одно. Существует два метода, чтобы найти все совпадения. Первый, который мы рассмотрим, это использование функции findall:

import re

silly_string = «the cat in the hat»
pattern = «the»

a = re.findall(pattern, silly_string)
print(a) # [‘the’, ‘the’]

Функция findall будет искать по всей переданной ей строке, и впишет каждое совпадение в список. По окончанию поиска вышей строки, она выдаст список совпадений. Второй способ найти несколько совпадений, это использовать функцию finditer:

import re

silly_string = «the cat in the hat»
pattern = «the»

for match in re.finditer(pattern, silly_string):
s = «Found ‘{group}’ at {begin}:{end}».format(
group=match.group(), begin=match.start(),
end=match.end())

print(s)

Как вы могли догадаться, метод finditer возвращает итератор экземпляров Match, вместо строк, которые мы получаем от findall. Так что нам нужно немного подформатировать результаты перед их выводом. Попробуйте запустить данный код и посмотрите, как он работает.

Сложности с обратными косыми

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

Давайте представим, что вам нужно найти строку на подобии этой: «python». Для её поиска в регулярном выражении, вам нужно будет использовать обратную косую, но, так как Python также использует обратную косую, так что на выходе вы получите следующий поисковый паттерн: «\\python» (без скобок). К счастью, Python поддерживает сырые строки, путем подстановки буквы r перед строкой. Так что мы можем сделать выдачу более читабельной, введя следующее: r”\python”. Так что если вам нужно найти что-то с обратной косой в названии, убедитесь, что используете сырые строки для этой цели, иначе можете получить совсем не то, что ищете.

Подведем итоги

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

Документация по модулю Re для Python 3 на русском ~ PythonRu

Регулярные выражения — специальная последовательность символов, которая помогает сопоставлять или находить строки python с использованием специализированного синтаксиса, содержащегося в шаблоне. Регулярные выражения распространены в мире UNIX.

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

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

Функция match

Эта функция ищет pattern в string и поддерживает настройки с помощью дополнительного flags.
Ниже можно увидеть синтаксис данной функции:

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

Описание параметров:

Функция re.match возвращает объект match при успешном завершении, или None при ошибке. Мы используем функцию group(num) или groups() объекта match для получения результатов поиска.

Пример функции re.match

import re


title = "Error 404. Page not found"
exemple = re.match( r'(.*)\. (.*?) .*', title, re.M|re.I)

if exemple:
   print("exemple.group() : ", exemple.group())
   print("exemple.group(1) : ", exemple.group(1))
   print("exemple.group(2) : ", exemple.group(2))
   print("exemple.groups():", exemple.groups())
else:
   print("Нет совпадений!")

Когда вышеуказанный код выполняется, он производит следующий результат:

exemple.group(): Error 404. Page not found
exemple.group(1): Error 404
exemple.group(2): Page
exemple.groups(): ('Error 404', 'Page')

Функция search

Эта функция выполняет поиск первого вхождения pattern внутри string с дополнительным flags.
Пример синтаксиса для этой функции:

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

Описание параметров:

Подписывайтесь на телеграм каналы

Функция re.search возвращает объект match если совпадение найдено, и None, когда нет совпадений. Используйте функцию group(num) или groups() объекта match для получения результата функции.

Пример функции re.search

import re


title = "Error 404. Page not found"

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

if exemple:
   print("exemple.group():", exemple.group())
   print("exemple.group(1):", exemple.group(1))
   print("exemple.group(2):", exemple.group(2))
   print("exemple.groups():", exemple.groups())
else:
   print("Нет совпадений!")

Запускаем скрипт и получаем следующий результат:

exemple.group():  404. Page not found
exemple.group(1): 404
exemple.group(2): Page
exemple.groups(): ('404', 'Page')

Match и Search

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

Пример разницы re.match и re.search

import re


title = "Error 404. Page not found"
match_exemple = re.match( r'not', title, re.M|re.I)

if match_exemple:
   print("match --> match_exemple.group():", match_exemple.group())
else:
   print("Нет совпадений!")

search_exemple = re.search( r'not', title, re.M|re.I)
if search_exemple:
   print("search --> search_exemple.group():", search_exemple.group())
else:
   print("Нет совпадений!")

Когда этот код выполняется, он производит следующий результат:

Нет совпадений!
search --> search_exemple.group(): not

Метод Sub

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

re.sub(pattern, repl, string, max=0)

Этот метод заменяет все вхождения pattern в string на repl, если не указано на max. Он возвращает измененную строку.

Пример

import re


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


dob = re.sub(r'#.*$', "", born)
print("Дата рождения:", dob)


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

Запускаем скрипт и получаем вывод:

Дата рождения: 05-03-1987 
05.03.1987 # Дата рождения

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

Функции регулярных выражений включают необязательный модификатор для управления изменения условий поиска. Модификаторы задают в необязательном параметре flags. Несколько модификаторов задают с помощью побитового ИЛИ (|), как показано в примерах выше.

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

За исключением символов (+?. * ^ $ () [] {} | ), все остальные соответствуют самим себе. Вы можете избежать экранировать специальный символ с помощью бэкслеша (/).

В таблицах ниже описаны все символы и комбинации символов для регулярных выражений, которые доступны в Python:

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

Поиск по буквам

python – находит “python”. |

Поиск по наборам символов

Специальные классы символов

Случаи повторения

Жадный поиск

Группирование со скобками

Ссылки на группы

Или

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

Специальный синтаксис в группах

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

Введение

Примеры

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

Первый аргумент re.match() является регулярным выражением, вторая строка , чтобы соответствовать:

 import re

pattern = r"123"
string = "123zzb"

re.match(pattern, string)
# Out: <_sre.SRE_Match object; span=(0, 3), match='123'>

match = re.match(pattern, string)

match.group()
# Out: '123' 

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

Сырые строковый литерал имеет несколько иного синтаксис , чем строка буквального, а именно обратный слэш \ в сыре строковых литералов означает «только обратной косой черты» , и нет никакой необходимости удвоения люфтов , чтобы избежать «экранирующих последовательностей» , такие как символ новой строки ( \n ) , вкладки ( \t ), забой ( \ ), формы-каналы ( \r ), и так далее. В обычных строковых литералах каждый обратный слеш должен быть удвоен, чтобы его не принимали за начало escape-последовательности.

Следовательно, r"\n" является строкой из 2 -х символов: \ и n . Regex модель также использовать обратную косую черту, например , \d относится к любому цифровому символу. Мы можем избежать того , чтобы удвоить наши избежать строки ( "\\d" ) с использованием сырьевых строк ( r"\d" ).

Например:

 string = "\\t123zzb" # here the backslash is escaped, so there's no tab, just '\' and 't'
pattern = "\\t123"   # this will match \t (escaping the backslash) followed by 123
re.match(pattern, string).group()   # no match
re.match(pattern, "\t123zzb").group()  # matches '\t123'

pattern = r"\\t123"  
re.match(pattern, string).group()   # matches '\\t123' 

Сопоставление выполняется только с начала строки. Если вы хотите , чтобы соответствовать в любом месте использовать re.search вместо:

 match = re.match(r"(123)", "a123zzb")

match is None
# Out: True

match = re.search(r"(123)", "a123zzb")

match.group()
# Out: '123' 

поиск

 pattern = r"(your base)"
sentence = "All your base are belong to us."

match = re.search(pattern, sentence)
match.group(1)
# Out: 'your base'

match = re.search(r"(belong.*)", sentence)
match.group(1)
# Out: 'belong to us.' 

Поиск осуществляется в любом месте строки , в отличие от re.match . Вы можете также использовать re.findall .

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

 match = re.search(r"^123", "123zzb")
match.group(0)
# Out: '123'

match = re.search(r"^123", "a123zzb")
match is None
# Out: True 

в конце строки (используйте $ ),

 match = re.search(r"123$", "zzb123")
match.group(0)
# Out: '123'

match = re.search(r"123$", "123zzb")
match is None
# Out: True 

или оба (использовать оба ^ и $ ):

 match = re.search(r"^123$", "123")
match.group(0)
# Out: '123' 

группирование

Группировка осуществляется с помощью скобок. Вызов group() возвращает строку , образованную из согласующих скобок подгрупп.

 match.group() # Group without argument returns the entire match found
# Out: '123'
match.group(0) # Specifying 0 gives the same result as specifying no argument
# Out: '123' 

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

Из документации :

Если есть единственный аргумент, результат — единственная строка; если имеется несколько аргументов, результатом является кортеж с одним элементом на аргумент.

Вызов groups() , с другой стороны, возвращает список кортежей , содержащих подгруппу.

 sentence = "This is a phone number 672-123-456-9910"
pattern = r".*(phone).*?([\d-]+)"

match = re.match(pattern, sentence)

match.groups()   # The entire match as a list of tuples of the paranthesized subgroups
# Out: ('phone', '672-123-456-9910')

m.group()        # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(0)       # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(1)       # The first parenthesized subgroup.
# Out: 'phone'

m.group(2)       # The second parenthesized subgroup.
# Out: '672-123-456-9910'

m.group(1, 2)    # Multiple arguments give us a tuple.
# Out: ('phone', '672-123-456-9910') 

 match = re.search(r'My name is (?P<name>[A-Za-z ]+)', 'My name is John Smith')
match.group('name')
# Out: 'John Smith'

match.group(1)
# Out: 'John Smith' 

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

Используя (?:) создает группу, но группа не улавливается. Это означает, что вы можете использовать его как группу, но это не будет загрязнять ваше «групповое пространство».

 re.match(r'(\d+)(\+(\d+))?', '11+22').groups()
# Out: ('11', '+22', '22')

re.match(r'(\d+)(?:\+(\d+))?', '11+22').groups()
# Out: ('11', '22') 

Этот пример соответствует 11+22 или 11 , но не 11+ . Это так + знак и второй член сгруппированы. С другой стороны, + знак не улавливается.

Экранирование специальных персонажей

Специальные символы (например , класса символов скобки [ и ] ниже) не соответствуют буквально:

 match = re.search(r'[b]', 'a[b]c')
match.group()
# Out: 'b' 

Избегая специальных символов, они могут быть сопоставлены буквально:

 match = re.search(r'\[b\]', 'a[b]c')
match.group()
# Out: '[b]' 

re.escape() функция может использоваться , чтобы сделать это для вас:

 re.escape('a[b]c')
# Out: 'a\\[b\\]c'
match = re.search(re.escape('a[b]c'), 'a[b]c')
match.group()
# Out: 'a[b]c' 

re.escape() функция экранирует все специальные символы, так что это полезно , если вы составляете регулярное выражение на основе пользовательского ввода:

 username = 'A.C.'  # suppose this came from the user
re.findall(r'Hi {}!'.format(username), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!', 'Hi ABCD!']
re.findall(r'Hi {}!'.format(re.escape(username)), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!'] 

Замена

Замены могут быть сделаны на строки , используя re.sub .

 re.sub(r"t[0-9][0-9]", "foo", "my name t13 is t44 what t99 ever t44")
# Out: 'my name foo is foo what foo ever foo' 

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

 re.sub(r"t([0-9])([0-9])", r"t\2\1", "t13 t19 t81 t25")
# Out: 't31 t91 t18 t52' 

Тем не менее, если вы сделаете идентификатор группы , как «10», это не работает : \10 чита

объект re.Match, методы re.search, re.finditer, re.findall

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


Существует два
различных подхода применения регулярных выражений:


• 
«здесь
и сейчас» для однократного применения правила;

• 
компиляция
и обработка, для многократного использования одного и того же правила.

Ранее, во всех
наших примерах мы использовали режим «здесь и сейчас». Например, для выделения
из строки шаблона цвета в формате:


#xxxxxx


где x – шестнадцатиричное
число, можно записать такую программу:


import re
 
text = "<font color=#CC0000>"
match = re.search(r"#[\da-fA-F]{6}\b", text)
print(match)

Мы здесь
определяем шаблон в виде:


«#[\da-fA-F]{6}\b»


который передаем
в виде строки первым параметром метода search, и на выходе
получаем объект re.Match со следующими
свойствами:


<re.Match
object; span=(12, 19), match=’#CC0000′>


Если же
вхождение не будет найдено, то метод search возвращает
значение None:


match = re.search(r"#[\da-fA-F]{7}\b", text)

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


Свойства и методы объекта re.Match

Давайте теперь
посмотрим на методы объекта re.Match. И, для его
исследования возьмем вот такое регулярное выражение:


match = re.search(r"(\w+)=(#[\da-fA-F]{6})\b", text)

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


И мы в этом
можем легко убедиться, вызвав метод group объекта re.Match:


match.group(0)
match.group(1)
match.group(2)

Или же, указать
все эти индексы через запятую:


На выходе
получим кортеж из соответствующих вхождений:


(‘color=#CC0000’,
‘color’, ‘#CC0000’)


Также можно
вызвать метод


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


Свойство lastindex содержит индекс
последней группы:


Если нам нужно
узнать позиции в тексте начала и конца группы, то для этого служат методы start и end:


match.start(1)
match.end(1)

Если по каким-то
причинам группа не участвовала в совпадении (например, ее вхождение было от 0),
то данные методы возвращают -1. Также мы можем получить сразу кортеж с
начальной и конечной позициями для каждой группы:


match.span(0)
match.span(1)

Для определения первого
и последнего индексов, в пределах которых осуществлялась проверка в тексте,
служат свойства:


Следующее
свойство re:


возвращает
скомпилированное регулярное выражение. А свойство string:


содержит
анализируемую строку.


Давайте теперь
реализуем такой шаблон:


match = re.search(r"(?P<key>\w+)=(?P<value>#[\da-fA-F]{6})\b", text)

мы здесь
определили две именованных группы: key и value. В результате,
с помощью метода:


можно получить
словарь:


{‘key’:
‘color’, ‘value’: ‘#CC0000’}


Свойство


возвращает имя
последней группы (или значение None, если именованных групп нет). Наконец,
с помощью метода


match.expand(r"\g<key>:\g<value>")

можно
формировать строку с использованием сохраненных групп:


‘color:#CC0000’


Здесь синтаксис:


• 
\g<name> — обращение
к группе по имени;

• 
\1,
\2, … — обращение к группе по номеру.

Вот такие возможности извлечения
результатов обработки строк дает объект re.Match.


Методы re.search, re.finditer и re.findall

В заключение этого занятия снова
обратимся к методу re.search для поиска первого вхождения в
тексте, удовлетворяющего регулярному выражению. Полный синтаксис этого метода
следующий:


re.search(pattern,
string, flags)


• 
pattern – регулярное
выражение;

• 
string
– анализируемая
строка;

• 
flags – один или
несколько флагов.

Ключевой
особенностью метода является поиск именно первого вхождения. Например, если
взять вот такой текст:


text = "<font color=#CC0000 bg=#ffffff>"

и выполнить его
анализ:


match = re.search(r"(?P<key>\w+)=(?P<value>#[\da-fA-F]{6})\b", text)

то второй
атрибут никак не будет фигурировать в результатах объекта match:


выведет всего
две группы для первого атрибута:


(‘color’, ‘#CC0000’)


Если нужно найти
все совпадения, то можно воспользоваться методом


re.finditer(pattern,
string, flags)


который
возвращает итерируемый объект для перебора всех вхождений:


for m in re.finditer(r"(?P<key>\w+)=(?P<value>#[\da-fA-F]{6})\b", text):
    print(m.groups())

На выходе
получим две коллекции для первого и второго атрибутов:


(‘color’,
‘#CC0000’)


(‘bg’,
‘#ffffff’)


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


re.findall(pattern,
string, flags)


следующим образом:


match = re.findall(r"(?P<key>\w+)=(?P<value>#[\da-fA-F]{6})\b", text)
print(match)

На выходе будет
список кортежей:


[(‘color’,
‘#CC0000’), (‘bg’, ‘#ffffff’)]


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


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


7.2. re — Операции с регулярными выражениями — документация Python 2.7.18

Этот модуль предоставляет операции сопоставления регулярных выражений, аналогичные
те, что есть в Perl. И шаблоны, и строки для поиска могут быть
Строки Unicode, а также 8-битные строки.

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

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

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

7.2.1. Синтаксис регулярного выражения

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

Регулярные выражения могут быть объединены в новые регулярные выражения; если A
и B являются регулярными выражениями, тогда AB также являются регулярными выражениями.В общем, если строка p соответствует A , а другая строка q соответствует B ,
строка pq будет соответствовать AB. Это справедливо, если только A или B не содержат низкий приоритет.
операции; граничные условия между A и B ; или иметь пронумерованную группу
Ссылки. Таким образом, сложные выражения можно легко построить из более простых
примитивные выражения, подобные описанным здесь. Подробнее о теории
и реализации регулярных выражений, обратитесь к упомянутой книге Фридла
выше, или почти любой учебник по построению компиляторов.

Далее следует краткое объяснение формата регулярных выражений. Для дальнейшего
информацию и более мягкое изложение, обратитесь к Regular Expression HOWTO.

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

Некоторые символы, например '|' или '(' , являются специальными. Специальные
персонажи либо обозначают классы обычных персонажей, либо влияют на
как интерпретируются окружающие их регулярные выражения. Обычный
строки шаблона выражения не могут содержать нулевые байты, но могут указывать
нулевой байт в нотации \ number , e.г., '\ x00' .

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

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

'.'

(Caret.) Соответствует началу строки, а также в режиме MULTILINE
соответствует сразу после каждой новой строки.

'$'

Соответствует концу строки или непосредственно перед новой строкой в ​​конце
строка, а в режиме MULTILINE также соответствует перед новой строкой. foo
соответствует как «foo», так и «foobar», а регулярное выражение foo $ соответствует
только «фу». Что еще интереснее, поиск foo. долларов из 'foo1 \ nfoo2 \ n'
обычно совпадает с «foo2», но с «foo1» в режиме MULTILINE ; поиск
один $ в 'foo \ n' найдет два (пустых) совпадения: одно непосредственно перед
перевод строки и один в конце строки.

'*'

Заставляет результирующий RE соответствовать 0 или более повторениям предыдущего RE, как
как можно больше повторений. ab * будет соответствовать «a», «ab» или «a», за которыми следует
на любое количество знаков «б».

'+'

Заставляет результирующий RE соответствовать 1 или нескольким повторениям предыдущего RE.
ab + будет соответствовать «a», за которым следует любое ненулевое число «b»; он не будет
совпадать просто «а».

'?'

Заставляет результирующий RE соответствовать 0 или 1 повторениям предыдущего RE.
ab? будет соответствовать либо «a», либо «ab».

*? , +? , ??

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

{m}

Указывает, что должно быть сопоставлено ровно m копий предыдущего RE; меньше
совпадения приводят к тому, что весь RE не совпадает.Например, {6} будет соответствовать
ровно шесть 'а' знаков, но не пять.

{m, n}

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

{м, п}?

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

'\'

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

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

[]

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

• Символы могут быть перечислены индивидуально, например [amk] будет соответствовать 'a' ,
м или к .

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

.

re.match (), re.search (), re.findall () с примером

• Home

• Testing

  • • Back
    • Agile Testing
    • BugZilla
    • Cucumber
    • Testing Тестирование ETL
    • Jmeter
    • JIRA
    • Назад
    • JUnit
    • LoadRunner
    • Ручное тестирование
    • Мобильное тестирование
    • Mantis
    • Backman
    • QTP
    • QTP QTP
    • QTP RPA
    • SAP Testing
    • Selenium
    • SoapUI
    • Управление тестированием
    • TestLink

• SAP

  • • Назад
    • ABAP
    • APO
    • Начинающий
    • Basis
    • BODS
    • BI
    • BPC
    • CO
    • Назад
    • CRM
    • Crystal Reports
    • Crystal Reports
    • FICO3
    • Заработная плата
    • Назад
    • PI / PO
    • PP
    • SD
    • SAPUI5
    • Безопасность
    • Менеджер решений
    • Successfactors
    • SAP Tutorials

    4

  • Web
  • Apache
  • AngularJS
  • ASP.Net
  • C
  • C #
  • C ++
  • CodeIgniter
  • СУБД
  • JavaScript
  • Назад
  • Java
  • JSP
  • Kotlin
  • Linux
  • Linux
  • Kotlin
  • Linux

  js

  • Perl
  • Назад
  • PHP
  • PL / SQL
  • PostgreSQL
  • Python
  • ReactJS
  • Ruby & Rails
  • Scala
  • SQL

  000

  • SQL

  000

  0003 SQL

  000

  0003 SQL

  000

  • UML
  • VB.Net
  • VBScript
  • Веб-службы
  • WPF