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

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

• Что такое регулярные выражения в Python?
• Функции регулярных выражений в Python
• Функция search()
• Объект Match
• Функция match()
• Функция fullmatch()
• Регулярные выражения и необработанные строки

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

Регулярные выражения (называемые regex или regexp) определяют шаблоны поиска. Типичными примерами регулярных выражений являются шаблоны для сопоставления адресов электронной почты, номеров телефонов и номеров кредитных карт.

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

Ниже показан пример простого регулярного выражения:

'\d'

В этом примере регулярное выражение представляет собой строку, содержащую шаблон поиска. ‘\d’ — это набор символов, который соответствует любой отдельной цифре от 0 до 9.

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

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

• Сначала импортируйте модуль re:

import re

• Во-вторых, скомпилируйте регулярное выражение в объект Pattern:

p = re.compile('\d')

• В-третьих, используйте один из методов объекта Pattern для сопоставления строки:

s = "Python 3.10 was released on October 04, 2021"
result = p.findall(s)

print(result)

Выход:

['3', '1', '0', '0', '4', '2', '0', '2', '1']

Метод findall() возвращает список одиночных цифр в строке s.

Ниже показана полная программа:

import re


p = re.compile('\d')
s = "Python 3.10 was released on October 04, 2021"

results = p.findall(s)
print(results)

Помимо метода findall(), объект Pattern имеет и другие важные методы, которые позволяют сопоставлять строку:

Метод	Цель
match()	Найти шаблон в начале строки
search()	Вернуть первое совпадение шаблона в строке
findall()	Вернуть все совпадения шаблона в строке
finditer()	Вернуть все совпадения шаблона в виде итератора

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

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

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

В следующем примере показана та же программа, которая использует функцию findall() вместо метода findall() объекта Pattern:

import re

s = "Python 3.10 was released on October 04, 2021."
results = re.findall('\d',s)
print(results)

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

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

Стоит ли использовать функции re или методы объекта Pattern?

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

В следующих разделах обсуждаются наиболее часто используемые функции модуля re, включая search(), match() и fullmatch().

Функция search()

Функция search() ищет шаблон внутри строки. Если совпадение есть, оно возвращает первый объект Match или None в противном случае. Например:

import re

s = "Python 3.10 was released on October 04, 2021."

pattern = '\d{2}'
match = re.search(pattern, s) 
print(type(match))
print(match)

Выход:

<class 're.Match'>
<re.Match object; span=(9, 11), match='10'>

В этом примере функция search() возвращает первые две цифры строки s в качестве объекта Match.

Объект Match

Объект Match предоставляет информацию о совпадающей строке. Он имеет следующие важные методы:

Метод	Описание
group()	Вернуть совпавшую строку
start()	Вернуть исходную позицию
end()	Вернуть конечную позицию
span()	Возвращает кортеж(начало, конец), указывающий позиции совпадения.

В следующем примере рассматривается объект Match:

import re


s = "Python 3.10 was released on October 04, 2021."
result = re.search('\d', s) 

print('Matched string:',result.group())
print('Starting position:', result.start())
print('Ending position:',result.end())
print('Positions:',result.span())

Выход:

Matched string: 3
Starting position: 7
Ending position: 8
Positions:(7, 8)

Функция match()

Функция match() возвращает объект Match, если обнаруживает шаблон в начале строки. Например:

import re

l = ['Python', 
    'CPython is an implementation of Python written in C', 
    'Jython is a Java implementation of Python',
     'IronPython is Python on .NET framework']

pattern = '\wython'
for s in l:
    result = re.match(pattern,s)
    print(result)

Выход:

<re.Match object; span=(0, 6), match='Python'>
None
<re.Match object; span=(0, 6), match='Jython'>
None

В этом примере \w — это набор символов слова, который соответствует любому отдельному символу.

\wython соответствует любой строке, которая начинается с любого символа слова, за которым следует литеральная строка ython, например, Python.

Поскольку функция match() находит шаблон только в начале строки, следующие строки соответствуют шаблону:

Python
Jython is a Java implementation of Python

И следующая строка не соответствует:

'CPython is an implementation of Python written in C'
'IronPython is Python on .NET framework'

Функция fullmatch()

Функция fullmatch() возвращает объект Match, если вся строка соответствует шаблону, или None в противном случае. В следующем примере функция fullmatch() используется для сопоставления строки из четырех цифр:

import re

s = "2021"
pattern = '\d{4}'
result = re.fullmatch(pattern, s)
print(result)

Выход:

<re.Match object; span=(0, 4), match='2019'>

Шаблон ‘\d{4}’ соответствует строке из четырех цифр. Таким образом, функция fullmatch() возвращает строку 2021.

Если вы поместите число 2021 в середину или конец строки, функция fullmatch() вернет None. Например:

import re

s = "Python 3.10 released in 2021"
pattern = '\d{4}'
result = re.fullmatch(pattern, s)
print(result)

Выход:

None

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

Важно отметить, что Python и регулярные выражения — это разные языки программирования. У них есть свой синтаксис.

Модуль re — это интерфейс между Python и языками программирования регулярных выражений. Он ведет себя как переводчик между ними.

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

Например, предположим, что вам нужно сопоставить следующую строку:

s = '\section'

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

pattern = '\\section'

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

pattern = '\\\\section'

Проще говоря, чтобы сопоставить буквальную обратную косую черту(‘\’), вам нужно написать ‘\\\\’, потому что регулярное выражение должно быть ‘\\’, а каждая обратная косая черта должна быть выражена как ‘\\’ внутри строкового литерала в Python.

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

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

Чтобы превратить обычную строку в необработанную, добавьте к ней префикс буквы r или R. Например:

import re

s = '\section'
pattern = r'\\section'
result = re.findall(pattern, s)

print(result)

Выход:

['\\section']

Обратите внимание, что в Python ‘\section’ и ‘\\section’ одинаковы:

p1 = '\\section'
p2 = '\section'

print(p1==p2) # true

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