Блог

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

Пример:

import re

s = 'ProgramBox: A computer science portal for geeks'

match = re.search(r'portal', s)

print('Start Index:', match.start())
print('End Index:', match.end())

Выход:

Начальный индекс: 34
Конечный индекс: 40

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

Примечание: Здесь символ r (r ‘ portal’) обозначает необработанное, а не регулярное выражение. Необработанная строка немного отличается от обычной строки, она не будет интерпретировать символ \ как escape-символ. Это связано с тем, что механизм регулярных выражений использует символ \ для своей собственной цели экранирования.

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

Метасимволы

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

Метасимволы	Описание
\	Используется для того, чтобы отбросить особое значение символа, следующего за ним
[]	Представляют класс символов
^	Соответствует началу
$	Соответствует концу
.	Соответствует любому символу, кроме новой строки
|	Означает ИЛИ (Совпадает с любым из символов, разделенных им.
?	Соответствует нулю или одному вхождению
*	Любое количество вхождений (включая 0 вхождений)
+	Одно или несколько происшествий
{}	Укажите количество совпадающих вхождений предыдущего регулярного выражения.
()	Вложите группу регулярных выражений

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

\ – Обратная Косая черта

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

Пример: 

import re

s = 'geeks.forgeeks'

# without using \
match = re.search(r'.', s)
print(match)
				
# using \
match = re.search(r'\.', s)
print(match)

Выход:

<_sre.SRE_Match объект; span=(0, 1), match='g'>
<_sre.SRE_Match объект; span=(5, 6), match='.'>

[] – Квадратные Скобки

Квадратные скобки ([]) представляют класс символов, состоящий из набора символов, которым мы хотим соответствовать. Например, класс символов [abc] будет соответствовать любому отдельному a, b или c.

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

• [0, 3] является образцом как [0123]
• [a-c] то же самое, что [abc]

Мы также можем инвертировать класс символов, используя символ каретки (^). Например,

• [^0-3] означает любое число, кроме 0, 1, 2 или 3
• [^a-c] означает любой символ, кроме a, b или c

^ – Каретка

Символ каретки (^) совпадает с началом строки, т. е. проверяет, начинается ли строка с данного символа(символов) или нет. Например –

• ^g проверит, начинается ли строка с g, например, geeks, globe, girl, g и т. Д.
• ^ge проверит, начинается ли строка с ge, например geeks, geeksforgeeks и т. Д.

$ – Доллар

Символ доллара($) соответствует концу строки, т. е. проверяет, заканчивается ли строка заданным символом(символами) или нет. Например –

• s$ проверит строку, которая заканчивается на a, например, geeks, ends, s и т. Д.
• ks$ проверит строку, которая заканчивается на ks, такую как geeks, geeksforgeeks, ks и т. Д.

. – Точка

Символ точки(.) соответствует только одному символу, за исключением символа новой строки (\n). Например –

• a.b проверит строку, содержащую любой символ в месте точки, например acb, acbd, abbb и т. Д
• .. проверит, содержит ли строка не менее 2 символов

| – Или

Символ Или работает как оператор или, что означает, что он проверяет, присутствует ли шаблон до или после символа или в строке или нет. Например –

• a|b будет соответствовать любой строке, содержащей a или b, такой как acd, bcd, abcd и т.д.

? – Знак Вопроса

Знак вопроса(?) Проверяет, встречается ли строка перед знаком вопроса в регулярном представлении по крайней мере один раз или вообще не встречается. Например –

• ab?c будет сопоставлен для строки ac, acb, dabc, но не будет сопоставлен для abbc, потому что есть два b. Аналогично, он не будет сопоставлен для abdc, потому что за b не следует c.

* – Звезда

Символ звезды (*) соответствует нулю или более вхождениям регулярного выражения, предшествующего символу*. Например –

• ab*c будет сопоставлен для строки ac, abc, abbbc, dabc и т. Д., Но не будет сопоставлен для abdc, потому что за b не следует c.

+ – Plus

Символ Плюс (+) соответствует одному или нескольким вхождениям регулярного выражения, предшествующего символу+. Например –

• ab+c будет сопоставлен для строки abc, abbc, dabc, но не будет сопоставлен для ac, abdc, потому что в ac нет b, а за d в abdc не следует c.

{m, n} – Фигурные скобки

Фигурные скобки соответствуют любым повторениям, предшествующим регулярному выражению от m до n, включительно. Например –

• a{2, 4} будет сопоставлен для строки aaab, baaaac, gaad, но не будет сопоставлен для строк, таких как abc, bc, потому что в обоих случаях есть только один a или нет a.

(<regex>) – Группа

Символ группы используется для группировки подшаблонов. Например –

• (a|b)cd будет соответствовать таким строкам, как acd, abcd, gacd и т.д.

Специальные Последовательности

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

Список специальных последовательностей –

Особая последовательность	Описание	Примеры
\А	Совпадает, если строка начинается с заданного символа	\Afor	for geeks
\b	Совпадает, если слово начинается или заканчивается данным символом. \b(строка) проверит начало слова, а (строка)\b проверит окончание слова.	\bge	geeks
\B	Это противоположно \b, т. е. строка не должна начинаться или заканчиваться данным регулярным выражением.	\Bge	together
\d	Соответствует любой десятичной цифре, это эквивалентно классу набора [0-9]	\d	123
\D	Соответствует любому безразрядному символу, это эквивалентно классу набора [^0-9]	\D	geek1
\s	Соответствует любому символу пробела.	\s	gee ks
\S	Соответствует любому символу, не содержащему пробелов	\S	a bd
\w	Соответствует любому буквенно-цифровому символу, это эквивалентно классу [a-zA-Z0-9_].	\w	123
\W	Соответствует любому не буквенно-цифровому символу.	\W	>$
\Z	Соответствует, если строка заканчивается заданным регулярным выражением	ab\Z	abcdab

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

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

Пример: Импорт модуля re в Python

import re

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

re.findall() (найди все)

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

Пример: Поиск всех вхождений шаблона

# A Python program to demonstrate working of
# findall()
import re

# A sample text string where regular expression
# is searched.
string = """Hello my Number is 123456789 and
			my friend's number is 987654321"""

# A sample regular expression to find digits.
regex = '\d+'

match = re.findall(regex, string)
print(match)

# This example is contributed by Ayush Saluja.

Выход:

['123456789', '987654321']

re.compile() (повторная компиляция)

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

Пример 1:

# Module Regular Expression is imported
# using __import__().
import re

# compile() creates regular expression
# character class [a-e],
# which is equivalent to [abcde].
# class [abcde] will match with string with
# 'a', 'b', 'c', 'd', 'e'.
p = re.compile('[a-e]')

# findall() searches for the Regular Expression
# and return a list upon finding
print(p.findall("Aye, said Mr. Gibenson Stark"))

Выход:

["е", "а", "д", "б", "е", "а"]

Понимание результатов:

• Первое вхождение — «е “в” Да», а не «А», так как оно чувствительно к регистру.
• Следующее появление — «а’ в “сказал”, затем» d’ в “сказал”, за которым следуют «в’ и ‘е’ в “Гибенсоне”, последнее» а’ совпадает со “Старком”.
• Обратная косая черта метасимвола » \ » играет очень важную роль, поскольку она сигнализирует о различных последовательностях. Если обратная косая черта должна использоваться без ее особого значения в качестве метасимвола, используйте’\\’

Пример 2: Заданный класс [\s,.] будет соответствовать любому символу пробела,‘, ’ или,‘.’.

import re

# \d is equivalent to [0-9].
p = re.compile('\d')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))

# \d+ will match a group on [0-9], group
# of one or greater size
p = re.compile('\d+')
print(p.findall("I went to him at 11 A.M. on 4th July 1886"))

Выход:

['1', '1', '4', '1', '8', '8', '6']
['11', '4', '1886']

Пример 3:

import re

# \w is equivalent to [a-zA-Z0-9_].
p = re.compile('\w')
print(p.findall("He said * in some_lang."))

# \w+ matches to group of alphanumeric character.
p = re.compile('\w+')
print(p.findall("I went to him at 11 A.M., he \
said *** in some_language."))

# \W matches to non alphanumeric characters.
p = re.compile('\W')
print(p.findall("he said *** in some_language."))

Выход:

['H', 'e', 's', 'a', 'i', 'd', 'i', 'n', 's', 'o', 'm', 'e', '_', 'l', 'a', 'n', 'g']
['I', 'went', 'to', 'him', 'at', '11', 'A', 'M', 'he', 'said', 'in', 'some_language']
[' ', ' ', '*', '*', '*', ' ', ' ', '.']

Пример 4:

import re

# '*' replaces the no. of occurrence
# of a character.
p = re.compile('ab*')
print(p.findall("ababbaabbb"))

Выход:

['ab', 'abb', 'a', 'abb']

Понимание результатов:

• Наш RE-это ab*, который » a «сопровождается любыми номерами «b», начиная с 0.
• Вывод ‘ab», допустим из-за одного «a», сопровождаемого одним ‘b».
• Вывод ‘abb’, действителен из-за одного » a «в сопровождении 2 ‘b».
• Вывод ‘a», допустим из-за одного «a», сопровождаемого 0 ‘b».
• Вывод ‘abbb», действителен из-за одного » a «в сопровождении 3 ‘b».

re.split()  (разделение)

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

Синтаксис :

re.split(pattern, string, maxsplit=0, flags=0)

Первый параметр, pattern обозначает регулярное выражение, строка-это заданная строка, в которой будет выполняться поиск шаблона и в которой происходит разделение, значение maxsplit, если не указано, считается равным нулю «0», и если какое-либо ненулевое значение указано, то происходит не более такого количества разбиений. Если maxsplit = 1, то строка разделится только один раз, в результате чего появится список длиной 2. Флаги очень полезны и могут помочь сократить код, они не являются необходимыми параметрами, например: flags = re.IGNORECASE, в этом разбиении случай будет проигнорирован.

Пример 1:

from re import split

# '\W+' denotes Non-Alphanumeric Characters
# or group of characters Upon finding ','
# or whitespace ' ', the split(), splits the
# string from that point
print(split('\W+', 'Words, words , Words'))
print(split('\W+', "Word's words Words"))

# Here ':', ' ' ,',' are not AlphaNumeric thus,
# the point where splitting occurs
print(split('\W+', 'On 12th Jan 2016, at 11:02 AM'))

# '\d+' denotes Numeric Characters or group of
# characters Splitting occurs at '12', '2016',
# '11', '02' only
print(split('\d+', 'On 12th Jan 2016, at 11:02 AM'))

Выход:

['Words', 'words', 'Words']
['Word', 's', 'words', 'Words']
['On', '12th', 'Jan', '2016', 'at', '11', '02', 'AM']
['On ', 'th Jan ', ', at ', ':', ' AM']

Пример 2:

import re

# Splitting will occurs only once, at
# '12', returned list will have length 2
print(re.split('\d+', 'On 12th Jan 2016, at 11:02 AM', 1))

# 'Boy' and 'boy' will be treated same when
# flags = re.IGNORECASE
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here', flags=re.IGNORECASE))
print(re.split('[a-f]+', 'Aey, Boy oh boy, come here'))

Выход:

['On ', 'th Jan 2016, at 11:02 AM']
['', 'y, ', 'oy oh ', 'oy, ', 'om', ' h', 'r', '']
['A', 'y, Boy oh ', 'oy, ', 'om', ' h', 'r', '']

re.sub() (

‘Sub’ в функции обозначает подстроку, в данной строке выполняется поиск определенного шаблона регулярного выражения (3-й параметр), и при нахождении шаблона подстроки заменяется на repl(2-й параметр), счетчик проверяет и поддерживает количество раз, когда это происходит.

Синтаксис:

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

Пример 1:

import re

# Regular Expression pattern 'ub' matches the
# string at "Subject" and "Uber". As the CASE
# has been ignored, using Flag, 'ub' should
# match twice with the string Upon matching,
# 'ub' is replaced by '~*' in "Subject", and
# in "Uber", 'Ub' is replaced.
print(re.sub('ub', '~*', 'Subject has Uber booked already',
			flags=re.IGNORECASE))

# Consider the Case Sensitivity, 'Ub' in
# "Uber", will not be reaplced.
print(re.sub('ub', '~*', 'Subject has Uber booked already'))

# As count has been given value 1, the maximum
# times replacement occurs is 1
print(re.sub('ub', '~*', 'Subject has Uber booked already',
			count=1, flags=re.IGNORECASE))

# 'r' before the pattern denotes RE, \s is for
# start and end of a String.
print(re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam',
			flags=re.IGNORECASE))

Выход:

S~*ject has ~*er booked already
S~*ject has Uber booked already
S~*ject has Uber booked already
Baked Beans & Spam

re.subn() 

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

Синтаксис:

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

Пример:

import re

print(re.subn('ub', '~*', 'Subject has Uber booked already'))

t = re.subn('ub', '~*', 'Subject has Uber booked already',
			flags=re.IGNORECASE)
print(t)
print(len(t))

# This will give same output as sub() would have
print(t[0])

Выход:

('S~*ject has Uber booked already', 1)
('S~*ject has ~*er booked already', 2)
Length of Tuple is:  2
S~*ject has ~*er booked already

re.escape()

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

Синтаксис:

re.escape(string)

Пример:

import re

# escape() returns a string with BackSlash '\',
# before every Non-Alphanumeric Character
# In 1st case only ' ', is not alphanumeric
# In 2nd case, ' ', caret '^', '-', '[]', '\'
# are not alphanumeric
print(re.escape("This is Awesome even 1 AM"))
print(re.escape("I Asked what is this [a-9], he said \t ^WoW"))

Выход:

This\ is\ Awesome\ even\ 1\ AM
I\ Asked\ what\ is\ this\ \[a\-9\]\,\ he\ said\ \ \ \^WoW

re.search() (повторный поиск)

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

Пример: Поиск вхождения шаблона

# A Python program to demonstrate working of re.match().
import re

# Lets use a regular expression to match a date string
# in the form of Month name followed by day number
regex = r"([a-zA-Z]+) (\d+)"

match = re.search(regex, "I was born on June 24")

if match != None:

	# We reach here when the expression "([a-zA-Z]+) (\d+)"
	# matches the date string.

	# This will print [14, 21), since it matches at index 14
	# and ends at 21.
	print ("Match at index %s, %s" % (match.start(), match.end()))

	# We us group() method to get all the matches and
	# captured groups. The groups contain the matched values.
	# In particular:
	# match.group(0) always returns the fully matched string
	# match.group(1) match.group(2), ... return the capture
	# groups in order from left to right in the input string
	# match.group() is equivalent to match.group(0)

	# So this will print "June 24"
	print ("Full match: %s" % (match.group(0)))

	# So this will print "June"
	print ("Month: %s" % (match.group(1)))

	# So this will print "24"
	print ("Day: %s" % (match.group(2)))

else:
	print ("The regex pattern does not match.")

Выход:

Match at index 14, 21
Full match: June 24
Month: June
Day: 24

Match Object (Сопоставить объект)

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

Получение строки и регулярного выражения

math.re атрибут возвращает переданное регулярное выражение и match.string атрибут возвращает переданную строку.

Пример: Получение строки и регулярного выражения соответствующего объекта

import re

s = "Welcome to GeeksForGeeks"

# here x is the match object
res = re.search(r"\bG", s)

print(res.re)
print(res.string)

Выход:

re.compile('\\bG')
Welcome to GeeksForGeeks

Получение индекса соответствующего объекта

• метод start() возвращает начальный индекс согласованной подстроки
• метод end() возвращает конечный индекс согласованной подстроки
• метод span() возвращает кортеж, содержащий начальный и конечный индексы совпадающей подстроки

Пример: Получение индекса соответствующего объекта

import re

s = "Welcome to GeeksForGeeks"

# here x is the match object
res = re.search(r"\bGee", s)

print(res.start())
print(res.end())
print(res.span())

Выход:

11
14
(11, 14)

Получение совпадающей подстроки

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

Пример: Получение совпадающей подстроки

import re

s = "Welcome to GeeksForGeeks"

# here x is the match object
res = re.search(r"\D{2} t", s)

print(res.group())

Выход:

me t

В приведенном выше примере наш шаблон указывает для строки, содержащей не менее 2 символов, за которыми следует пробел, и за этим пробелом следует буква t.