Регулярные выражения (регулярность) в Python

Любой разработчик или желающий разработчик знает, насколько полезными могут быть регулярные выражения при работе со строками и текстом. Но, как правило, Ругара считается жесткой, и люди не хотят испачкать руки. По крайней мере, это было для меня, пока я не нашел это Тема Quora. Настоящий ответ в этом вопросе Quora, в некотором смысле, обеспечивает путь для изучения, понимания и практики регулярного выражения быстро и систематически. Я узнал из этого пути и собираюсь поделиться тем, что я узнал, чтобы любой мог найти всю информацию в одном месте.

Итак, что такое regex?

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

password should:
contain at least 6 alphanumeric characters,
start with an uppercase letter, 
end with at least one special symbol(*,@,# etc.)

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

'^[A-Z]\w{5}.*[*@#]$'

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

Create a password: 1223as //-->password cannot be created!!
Create a password: A123bc@# //-->password created!!

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

Работа с Regex (с помощью Python3)

Перво -наперво, Regex обычно используется с некоторыми языками программирования для работы в тексте из данного текстового файла или файла журнала и т. Д. Мы собираемся использовать Python для работы с Regex. Нужно быть немного знаком с синтаксисом Python, концепцией модулей и ООП для работы с ним. Чтобы использовать регулярные выражения в Python, нам нужно импортировать модуль RE. RE Module имеет много методов, которые облегчают работу с Regex. Мы быстро рассмотрим наиболее важные методы, с которыми могут выполнять почти все действия, связанные с повторной эксплуатацией. Объясняя эти методы, я буду использовать Regex в его простых терминах, то есть без какого -либо метахарактера. Metacharacters – это особые символы, которые используются в регулярных выражениях. Это заставит нас осознать, что регулярные выражения являются объектом типов струн, а не единственными сложными символами, которые обычно думают новички. В простейшей форме их можно использовать в качестве простых строковых объектов, как мы увидим. Основные методы, на которые мы собираемся посмотреть:

1. re.search ()

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

re.search(pattern,string,flags)
where the pattern is the regex written by you
the string is a string with which we want to match our pattern
flags are optional third arguments used for different purposes briefly discussed below

Посмотрим, как это работает.

import re
res=re.search(r'coding','dev is the best place to learn coding.')
print(res) 
res=re.search(r'code','dev is the best place to learn coding.')
print(res)

Вы можете запустить выше кода и увидеть результат самостоятельно, но для справки вывод вышеуказанного кода:

Output:
_sre.SRE_Match object; span=(31, 37), match='coding'
None

re.search () Возвращает то, что известно как объект соответствия, как показано выше, если регулярность совпадает со строкой. Если объект соответствия резервуара возвращается, он указывает на то, что шаблон был сопоставлен с строкой, и если нет такого шаблона, мы получаем «нет» в результате. Если мы хотим увидеть содержимое объекта Match, мы можем использовать метод группы (). Итак, замените оператор Print (RES) в вышеуказанном коде на print (res.group ()). Попробуйте это на ide самостоятельно, и вывод будет:

Output:
Runtime Errors:
Traceback (most recent call last):
  File "/home/f79b34f7380e5d299ca6998dec4c6fef.py", line 6, in 
    print(res.group())
AttributeError: 'NoneType' object has no attribute 'group'

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

2. re.match ()

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

# match() method of re module
import re
s1='China is the most populous country in the world'
s2='Most populous country in the world is China'
res=re.match(r'China',s1)
print(res) #prints Match object as China is at the beginning of s2.
res=re.match(r'China',s2)
print(res) #prints None as China is not at the beginning of s2.
if re.search('China',s1) and re.search('China',s2):
# another way to use search() and match()
print('search possible in s1 and s2')

Приведенный выше код показывает другой способ использования методов search () и match (). Если поиск происходит и шаблон сопоставлен, мы можем сделать что -то на основе этого.

Соответствующий старт и конец

Мы видели этот метод Match () возвращает объект совпадений только тогда, когда шаблон возникает в начале тестовой строки. Тем не менее, у нас есть другой способ достичь того же самого, и это с метахарактером ‘^’. Если мы хотим, чтобы наш шаблон произошел в начале тестовой строки, тогда мы можем использовать ^ в начале шаблона, как показано ниже. Мы используем «^» с помощью метода search (). Его сходство с матчем показано ниже. Вместо использования совпадения мы можем использовать поиск, как показано ниже:

# replacing match using search and ^
import re
s1='China is the most populous country in the world'
s2='Most populous country in the world is China'
res=re.search(r'^China',s1)
print(res) #prints Match object as China is at the beginning of the s1.
res=re.search(r'^China',s2)
print(res) #prints None as China is not at the beginning of the s2.

Output:
<_sre.SRE_Match object; span=(0, 5), match='China'>
None

Точно так же у нас есть Metacharacter ‘$’, который расположен в конце режима, а шаблон соответствует только в том случае, если заданный шаблон присутствует в конце тестовой строки. Пример:

# Using $ to match last characterset in the test string
import re
s1='China is the most populous country in the world'
s2='Most populous country in the world is China'
res=re.search(r'China$',s1)
print(res) #prints None as China is not at the end of s1.
res=re.search(r'China$',s2)
print(res) #prints Match object as China is at the end of s2.

Результаты сейчас просто обратно, так как у S2 в конце предложения «Китай».

Output:
None
<_sre.SRE_Match object; span=(38, 43), match='China'>

Если мы комбинируем как «^», так и «$» в шаблоне, тестовая строка будет соответствовать, если она содержит все, что находится между ‘^’ и ‘$’, и ничего больше. Пример:

import re
s1='China is the most populous country in the world'
s2='Most populous country in the world is China'
s3 = 'China'
res=re.search(r'^China$',s1)
print(res) #prints None as s1 does not start and end with 'China'.
res=re.search(r'^China$',s2)
print(res) #prints None as s2 does not start and end with 'China'.
res=re.search(r'^China$',s3)
print(res) #prints Match object as test string only contains "China" and nothing else.

Output:
None
None
<_sre.SRE_Match object; span=(0, 5), match='China'>

3. re.findall ()

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

import re
res=re.search(r'.at','the cat was chasing rat while the bat was looking at them')
print(res.group())

Где ‘.’ является метахарактером, который представляет любой персонаж, принимающий Newline. До сих пор мы использовали простые символы ASCII с помощью Regex, но в Regex также есть много метахарактеров, что позволяет нам создавать шаблоны, которые могут делать более мощные вещи. Позже мы увидим все важные метахарактеры в режиме. В приведенном выше случае записана только кошка, поэтому вывод будет «кошка». Но Что если мы хотим такие слова, то мы можем использовать циклы с помощью search (), либо мы можем использовать findall (), как показано ниже:

import re
res=re.findall(r'.at','the cat was chasing rat while bat was looking at them')
print(res)

Вывод:

Output:
['cat', 'rat', 'bat', ' at']

Итак, Findall () возвращает список всех непересекающихся совпадений шаблонов.

4. re.compile ()

С помощью re.compile () мы можем использовать шаблон режима снова и снова в нашем коде. Подпись re.compile:

re.compile(pattern,flags)
flags are optional arguments which we will see later.

Compile () возвращает объект, известный как объект Regex, который имеет свой собственный Search (), Match (), Findall () и другие методы, которые обычно имеют объект сопоставления. Таким образом, ниже приведен код, который показывает, как работает Compile (), и также показан альтернативный способ работы без Compile (). Там нет большой разницы между ними.

# compile method of re
import re
comp=re.compile('pattern')  #comp is a regex object not a match object
res=comp.search('the pattern is present in this sentence.') #res is match object
print(res,res.group())
res=re.search('pattern','the pattern is present in this sentence.') #alternate way without compile, here res is match object
print(res,res.group())

Output:
_sre.SRE_Match object; span=(4, 11), match='pattern' pattern
_sre.SRE_Match object; span=(4, 11), match='pattern' pattern

Дополнительный аргумент флага в методах повторения

Существует необязательный аргумент флага во всех методах соответствия шаблонов RE, объясненных ниже, например, search (), match (), findall () и compile (). Флаги могут изменить способ функции регулярных выражений. Для этого мы увидим один пример:

import re
res = re.findall(r'Noun','Noun is the naming word. We use noun to name objects', re.IGNORECASE)
print(res)

Output:
['Noun', 'noun']

Без 3 -го аргумента он соответствует только одному экземпляру «существительное», но когда мы используем Re. Игнореказ (также re. I) он игнорирует случай и соответствует оба экземпляра «существительное». Точно так же есть и другие значения флага. Если вы хотите узнать о них больше, вы можете направить это ссылка на сайт

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

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

1. Любой персонаж (.)

‘.’ это метахарактер, который соответствует что -либо в тестовой строке (строка, в которой мы ищем шаблоны), кроме новой линии. Как мы видели ранее в примере findall () выше, мы используем ». ‘ Когда мы не знаем заранее, какой персонаж мы хотим искать, например, пусть строка тестирования быть

"the house no. is 74-3B."

И мы обязаны посмотреть, есть ли дом нет. в соответствии с правилом числа, в котором говорится, что- Дом нет. Содержит два символа, за которым следует «-», и это за ним следовало два символа, затем мы можем написать регулярность как

"..-.."//matches test string mentioned above

Как любой персонаж может занять место вокруг »-« Мы использовали ».

2. Класс персонажей ([])

Когда мы пишем [] в корпорации, он представляет класс символов, и он соответствует только одним из нескольких символов внутри квадратных скобок. Если мы положим «^» в квадратные кронштейны перед всеми символами, то это соответствует любому персонажу, которого нет в квадратных скобках. Если мы поместим дефис (-) внутри квадратных кронштейнов, мы можем использовать его, чтобы соответствовать диапазону символов в некоторой последовательности. Следующий список примеров прояснит их:

3. Предопределенные классы персонажей

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

4. Квантификаторы

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

а ? ( Для дополнительного предшествующего символа)

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

import re
res=re.findall(r"army?", "the arms and ammunitions should be provided to the army for security")
print(res)

беременный *(ноль или более повторений)

Он используется, если мы хотим, чтобы предыдущий символ или группу символов повторялись ноль или более раз. Например:

import re
res = re.findall(r'ai*m', 'am aim aiim aiiims ai')
print(res)

Output:
['am', 'aim', 'aiim', 'aiiim']

Приведенный выше код показывает, что regex совпадает, если существует произвольное количество i между a и m.

в +(одно или несколько повторений)

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

import re
res = re.findall(r'ai+m', 'am aim aiim aiiims ai')
print(res)

Output:
['aim', 'aiim', 'aiiim']

Мы видим, что для той же тестовой строки соответствуют только те строки, которые имеют хотя бы одну «я», – и «и».

дюймовый {x} (Исправлено нет. Повторений)

Использование + и * это хорошо Но когда мы используем их, предыдущие символы могут повторить что -либо нет. времена. В некоторых ситуациях мы хотим, чтобы некоторые персонажи или группу персонажей повторяли, что вам не нужно. времена. Это может быть достигнуто с помощью {x}, который соответствует только тем, если предыдущие символы повторяются x n. времена. Например:

import re
print('Enter your phone no. it must be of 10 digits!!!')
phone = input()
res = re.search(r'\d{10}', phone)
if res:
    print("correct")
else:
    print("Incorrect no. of digits")

Если пользователь вводит что -то меньшее, чем более 10 цифр выше, он или она получит сообщение как «неверный нет. Цифров». Вывод, когда телефон нет. действителен и неверно показана ниже:

#valid
Output:
Enter your phone no. it must be of 10 digits!!!
9999999999
correct

#invalid
Output:
Enter your phone no. it must be of 10 digits!!!
100
Incorrect no. of digits

е – {x, y} (исправленные и дальние повторения):

В приведенном выше примере мы видим, что 100 оценивается как недействительный из -за нашего кода. Но 100 – это фактически, допустимое число. Так что иногда мы можем хотеть ограничения в диапазоне. Затем мы используем {x, y}, который соответствует только тем, если предыдущие символы повторяются как минимум x раз и в максимум y. Пример:

import re
print('Enter your phone no. it should be between 3 to 10 digits!!!')
phone = input()
res = re.search(r'\d{3,10}', phone)
if res:
    print("correct")
else:
    print("Incorrect no. of digits")

Output:
Enter your phone no. it should be between 3 to 10 digits!!!
100
correct

Если мы напишем {, y} это означает от 0 до y нет. из предыдущих символов разрешены, и если мы напишем {x,} это означает как минимум x символы и более нет. персонажей разрешены.

5. Группировка и захват

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

import re
for _ in range(3):
    print('Enter your phone no. it must be of 10 digits!!!. ISD code is optional.')
    phone = input()
    res = re.search(r'(\+\d{2})?\d{10}', phone)
    if res:
        print("correct")
    else:
        print("Incorrect no. of digits")

Output:
Enter your phone no. it must be of 10 digits!!!. ISD code is optional.
9999999999
correct
Enter your phone no. it must be of 10 digits!!!. ISD code is optional.
+919999999999
correct
Enter your phone no. it must be of 10 digits!!!. ISD code is optional.
988
Incorrect no. of digits

Приведенный выше пример показывает, как группы работают в режиме. Чтобы сделать код ISD необязательным, мы могли бы использовать ‘? «Характер оператора по характеру, но группы делают его очень удобным, так как он рассматривает всех этих символов как одну единицу. Мы сгруппировали персонажей и сделали его необязательным, применяя ‘?’ оператор сразу. Однако это не все, что мы можем сделать с группами. Мы можем захватить группы и использовать их позже в наших программах. Это делает Regex очень мощным. Мы можем извлечь и желаемые строки и рисунки и сделать с ними некоторую обработку.

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

группа()

До сих пор мы использовали совместные объекты только с операторами IF, но что, если мы хотим увидеть, какие символы были на самом деле сопоставлены данной тестовой строкой? Для этой цели мы используем метод группы (), который обсуждался кратко ранее. Метод Group () применяется на Match Object, возвращаемом Search () или Match (), как обсуждалось выше. Посмотрим пример:

import re
res=re.search(r'coding','dev is the best place to learn coding.')
print(res)
print(res.group())

Output:
<_sre.SRE_Match object; span=(31, 37), match='coding'>;
coding

Из приведенного выше вывода мы видим, что когда групповой метод используется в самой простой форме без каких -либо аргументов, он просто возвращает символы, которые были сопоставлены в объекте соответствия. Когда мы пытаемся распечатать саму, так как это объект сопоставления, который мы получаем <_sre. SRE_MATCH объект; span = (31, 37),> как вывод. Но когда мы печатаем res.group (), мы получаем фактическое содержание объекта соответствия, который был сопоставлен.

Альтернативное соответствие в группах

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

import re
regex = r'(Tom|Dick|Harry)'
res = re.search(regex, 'Tom is in the pattern')
res2 = re.search(regex, 'Dick is in the pattern')
res3 = re.search(regex, 'Harry is in the pattern')
res4 = re.search(regex, 'Sal is in the pattern')
print(res)
print(res2)
print(res3)
print(res4)

Output:
<_sre.SRE_Match object; span=(0, 3), match='Tom'>
<_sre.SRE_Match object; span=(0, 4), match='Dick'>
<_sre.SRE_Match object; span=(0, 5), match='Harry'>
None

Из примера выше мы видим, что любой шаблон из группы совпадает.

Захват и обратные ссылки

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

import re
res=re.search(r'(cod)ing','gfg is the best place to learn coding.')
print(res)
print(res.group())
print(res.group(1))

Output:
<_sre.SRE_Match object; span=(31, 37), match='coding'>
coding
cod

Как мы можем видеть после обертывания набора символов «COD» в парарантезе, мы сформировали группу (COD). Таким образом, чтобы получить все соответствующие символы, мы просто набираем res.group () и чтобы получить содержимое группы (COD), мы набираем res.group (1). Один естественный вопрос, который возникает, заключается в том, почему мы использовали 1 в качестве аргумента и ничего больше? Будет ясно, когда мы будем использовать несколько групп в одном и том же регулярном выражении. На самом деле это еще одно использование группы. Чтобы сгруппировать разные части выражения и использовать их в нашей программе удобно. Простой пример показан ниже:

import re
res=re.search(r'(cod)(ing)','gfg is the best place to learn coding.')
print(res)
print(res.group())
print(res.group(1))
print(res.group(2))

Output:
<_sre.SRE_Match object; span=(31, 37), match='coding'>
coding
cod
ing

Использование номера 1 и 2 в качестве аргументов становится очевидным сейчас. Числа указывают, что группы, начинающиеся слева направо, (самой левой группе в выражении присваивается значение 1, а затем значение увеличивается по мере продвижения вправо). И этот процесс – это то, что мы называем захватом. Мы можем использовать группы для захвата определенных наборов символов и использовать их в наших программах. Чтобы увидеть, как полезно захват, мы увидим пример, заимствованный из Hackerrank Анкет Проблема объяснена ниже:

Нам был предоставлен список телефонных номеров формата

[Country code]-[Local Area Code]-[Number] 

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

given number = 91-011-23413627
desired output after processing:
CountryCode=91,LocalAreaCode=011,Number=23413627

Некоторые ограничения:

1. Количество чисел, n находится в диапазоне.
2. Может быть либо ‘-‘ (значение 45), либо A ” (пространство, значение ASCII 32) между сегментами

Мы можем решить задачу выше с приведенным ниже кодом, используя группы и захват:

import re
for i in range(int(input())):
    s=input()
    res=re.search('([0-9]{1,3})[- ]([0-9]{1,3})[- ]([0-9]{4,10})',s)
    if res:
        print("CountryCode={},LocalAreaCode={},Number={}".format(res.group(1),res.group(2),res.group(3)))

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

1. Первый для .. в цикле используется потому, что пользователя спрашивают, сколько чисел они хотят обработать.
2. На каждом номере мы проверяем, соответствует ли числовая строка, которая должна содержать от 1 до 3 цифр в сегменте кода страны, от 1 до 3 цифр в сегменте кода локальной области и от 4 до 10 цифр в фактическом сегменте числа.
3. Мы используем группы для захвата каждого сегмента.
4. Мы отображаем каждый сегмент, используя метод группы с аргументами от 1 до 2 до 3 слева направо.

6. Обратные ссылки

Передние выращивания полезны, когда мы используем один и тот же текст или набор символов снова и снова в том же выражении. Всякий раз, когда мы создаем группу, она автоматически сохраняется в том, что мы называем как обратная ссылка, чтобы последнее ее можно было использовать в программе или самом выражении. Фактически, то, что мы использовали в качестве аргументов в методе группы (), на самом деле были обратными выражениями. Мы уже видели одно использование обратных секций. Это должно было использовать захваченные группы в нашей программе. Теперь мы увидим использование обратных секций внутри наших выражений. Если мы ищем одну и ту же группу персонажей, снова и снова мы можем использовать обратные ссылки. Например, посмотрим на регулярное выражение:

[A-Za-z]{3}\d{3}[A-Za-z]{3}

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

([A-Za-z]){3}\d{3}\1{3}

‘\ 1’ В приведенном выше примере представляет собой обратную ссылку группы ([A-za-z]) мы можем заменить все другие случаи этой группы на сохраненную обратную ссылку «\ 1 ‘. Нумерация выполняется так же, как группа группы, начиная с 1, и увеличивает числа слева направо.

Поиск и замените методом re.sub ()

Окончательным методом, который мы увидим перед закрытием этого учебника, является метод повторного модуля sub (), который помогает нам искать конкретный текст в тестовой строке и заменить его на желаемый текст. Подпись метода sub ():

re.sub(pattern, replacement, string)
where the pattern is the regex written by you
replacement is the string which we want to replace our pattern with
the string is a test string

Один простой пример показан ниже:

import re
test = "people in indie are called indiens"
res = re.sub(r'indie', 'India', test)
print(res)

Output:
people in India are called Indians

Вывод

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

1. Прочитайте еще несколько тем в деталях, как границы слов (\ b и \ b), разделяя регулярные выражения, больше флагов. Но, кроме этого, этот учебник охватил все основы.

2. Практика синтаксиса корзины из этого сайт

3. Практикуйте использование режима с питоном из Hackerrank Regex Track

Следуйте этим трем шагам после этого учебника, и у вас будут достаточно приличные знания, чтобы применять Regex не только на Python, но и на любом другом языке. Как говорят «практика делает постоянную».

Ваше здоровье!!

Кредиты (изображение обложки): изображение Msandersmusic из Pixabay

Оригинал: “https://dev.to/code_mind/regular-expressions-regex-in-python-2non”