Регулярные выражения (регулярное выражение) — это специальная последовательность символов, которая использует шаблон поиска для поиска строки или набора строк. Он может обнаруживать наличие или отсутствие текста путем сопоставления с определенным шаблоном, а также может разбивать шаблон на один или несколько подшаблонов. 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.