Автор оригинала: Esther Vaati.

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

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

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

Регулярные выражения-это в основном просто последовательность символов, которая может быть использована для определения шаблона поиска текста. Эта “поисковая система” встроена в язык программирования Python (а также во многие другие языки) и доступна через модуль re .

Чтобы использовать регулярные выражения (или сокращенно “регулярное выражение”), вы обычно указываете правила для набора возможных строк, которые вы хотите сопоставить, а затем задаете себе такие вопросы, как “Соответствует ли эта строка шаблону?” или “Есть ли совпадение для шаблона где-нибудь в этой строке?”.

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

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

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

Совпадающие Символы

Регулярные выражения могут содержать как специальные, так и обычные символы. Самые обычные символы, такие как “А”, ” а ” или “0”, являются простейшими регулярными выражениями; они просто совпадают сами с собой. Есть и другие специальные символы, которые не могут соответствовать сами себе, т. е. ^ , $ , * , + , ? , { , } , [ , ] , \ , | , ( , и ) . Это связано с тем, что они используются для функций сопоставления более высокого порядка, которые описаны далее в этой таблице:

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

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

1. ре.матч()
2. re.поиск()
3. re.поиск()
4. ре.раскол()
5. re.sub()
6. re.compile()

re.match(pattern, string,)

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

Приведенное ниже выражение вернет None , потому что Python не появляется в начале строки.

# match.py

import re
result = re.match(r'Python', 'It\'s  easy to learn Python. Python also has elegant syntax')

print(result)

$ python match.py
None

re.поиск(шаблон, строка)

Этот модуль проверяет совпадение anywhere в данной строке и возвращает результаты, если они найдены, и None если они не найдены.

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

# search.py

import re

if re.search("puppy", "Daisy found a puppy."):
    print("Puppy found")
else:
    print("No puppy")

Здесь мы сначала импортируем модуль re и используем его для поиска вхождения подстроки “puppy” в строку “Daisy found a puppy”. Если он существует в строке, возвращается объект re.Match , который считается “истинным” при вычислении в операторе if.

$ python search.py 
Puppy found

re.compile(шаблон,)

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

# compile.py

import re

pattern = re.compile('Python')
result = pattern.findall('Pythonistas are programmers that use Python, which is an easy-to-learn and powerful language.')

print(result)

find = pattern.findall('Python is easy to learn')

print(find)

$ python compile.py 
['Python', 'Python']
['Python']

Обратите внимание, что возвращается только совпадающая строка, в отличие от всего слова в случае “Pythonistas”. Это более полезно при использовании строки регулярного выражения, содержащей специальные символы соответствия.

re.sub(pattern, repl, string)

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

# sub.py

import re
result = re.sub(r'python', 'ruby', 'python is a very easy language')

print(result)

$ python sub.py 
ruby is a very easy language

re.findall(шаблон, строка)

Как вы уже видели до этого раздела, этот метод находит и извлекает список всех вхождений в данной строке. Он сочетает в себе как функции, так и свойства re.search() и re.match() . В следующем примере будут извлечены все вхождения “Python” из строки.

# findall.py

import re

result = re.findall(r'Python', 'Python is an easy to learn, powerful programming language. Python also has elegant syntax')
print(result)

$ python findall.py 
['Python', 'Python']

Опять же, использование такой строки точного соответствия (“Python”) действительно полезно только для того, чтобы найти, встречается ли строка регулярного выражения в данной строке или сколько раз она встречается.

re.split(шаблон, строка,,)

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

# split.py

import re

result =  re.split(r"y", "Daisy found a puppy")

if result:
    print(result)
else:
   print("No puppy")

Как вы можете видеть выше, шаблон символа “y” встречается три раза, и выражение разделилось во всех случаях, где оно встречается.

$ python split.py 
['Dais', ' found a pupp', '']

Практическое использование регулярных выражений

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

Построение URL-адресов

У каждой веб-страницы есть URL. Теперь представьте, что у вас есть сайт Django с адресом типа ” http://www.example.com/products/27/ “, где 27 – идентификатор продукта. Было бы очень громоздко писать отдельные представления, чтобы соответствовать каждому отдельному продукту.

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

Выражение, которое будет соответствовать и извлекать любой числовой идентификатор, может быть ^products/(\d+)/$ .

• ^products/ говорит Django, чтобы он соответствовал строке, которая имеет “products/” в начале URL-адреса (где “начало” строки задается ^ )
• (\(\d+) означает, что будет число (заданное \d+ ), и мы хотим, чтобы оно было захвачено и извлечено (задано скобками)
• (\(\d+) означает, что будет число (заданное
• \d+ ), и мы хотим, чтобы оно было захвачено и извлечено (задано скобками)

Проверка Адресов Электронной Почты

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

# validate_email.py

import re

email = "[email protected]"

if not re.match(re.compile(r'^[email protected][^.].*\.[a-z]{2,10}$', flags=re.IGNORECASE), email):
    print("Enter a valid email address")
else:
    print("Email address is valid")

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

• ^ [email protected] : Сопоставьте каждый символ от начала строки до символа’@’.

  • Совпадения ” [email protected] ” от “[email protected] “

• [^.].* : Соответствует каждому символу кроме “.”

  • Соответствует “gmail” из “[email protected] “

• \.[a-z]{2,10}$ : Сопоставьте символы домена TLD (с максимальной длиной 10 символов) до конца строки

  • Матчи “.com” от “[email protected] “

Итак, как и следовало ожидать, код совпадает с нашим примером адреса:

$ python validate_email.py 
Email address is valid

Проверка Правильности Телефонных Номеров

Следующий пример используется для проверки списка префиксных канадских номеров:

# validate_numbers.py

import re

numbers = ["+18009592809", "=18009592809"]

for number in numbers:
    if not re.match(re.compile(r"^(\+1?[-. ]?(\d+))$"), number):
        print("Number is not valid")
    else:
        print("Number is valid")

$ python validate_numbers.py 
Number is valid
Number is not valid

Как вы можете видеть, поскольку второе число использует+”, оно считается недействительным.

Фильтрация Нежелательного Контента

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

# filter.py

import re

curse_words = ["foo", "bar", "baz"]
comment = "This string contains a foo word."
curse_count = 0

for word in curse_words:
    if re.search(word, comment):
        curse_count += 1

print("Comment has " + str(curse_count) + " curse word(s).")

$ python filter.py 
Comment has 1 curse word(s).

Вывод

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