Некоторые репозитории в помощь изучающим и преподающим python и машинное обучение

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

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

Первый пример был о поиске слова . В Python, мы можем сделать это следующим образом:

Если вы запустите этот скрипт-код в Python, то на выходе вы получите: !

На самом деле скрипт работает нормально, все дело в том, как работает функция . Если мы обратимся к документации по поводу модуля , вот что мы увидим о работе функции .

Получается, функция возвращает результат, если соответсвие найдено в начале строки.

Вместо этого нам следует использовать функцию , которая, основываясь на документации:

Так что если мы напишем код, но вместо , мы получим следующий результат:

Это значит, что функция возвратила .

Если мы хотим, что бы результат был возвращен в виде строки, мы должны использовать функцию . Если мы хотим увидеть совпадение целиком, мы должны использовать group(0). Таким образом:

вернет: .

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

Результатом работы этого скрипта будет: .

Common Problems¶

Regular expressions are a powerful tool for some applications, but in some ways
their behaviour isn’t intuitive and at times they don’t behave the way you may
expect them to. This section will point out some of the most common pitfalls.

Use String Methods

Sometimes using the module is a mistake. If you’re matching a fixed
string, or a single character class, and you’re not using any features
such as the flag, then the full power of regular expressions
may not be required. Strings have several methods for performing operations with
fixed strings and they’re usually much faster, because the implementation is a
single small C loop that’s been optimized for the purpose, instead of the large,
more generalized regular expression engine.

One example might be replacing a single fixed string with another one; for
example, you might replace with . seems like the
function to use for this, but consider the method. Note that
will also replace inside words, turning
into , but the naive RE would have done that, too. (To
avoid performing the substitution on parts of words, the pattern would have to
be , in order to require that have a word boundary on
either side. This takes the job beyond ’s abilities.)

Another common task is deleting every occurrence of a single character from a
string or replacing it with another single character. You might do this with
something like , but is capable of
doing both tasks and will be faster than any regular expression operation can
be.

In short, before turning to the module, consider whether your problem
can be solved with a faster and simpler string method.

match() versus search()

The function only checks if the RE matches at the beginning of the
string while will scan forward through the string for a match.
It’s important to keep this distinction in mind. Remember, will
only report a successful match which will start at 0; if the match wouldn’t
start at zero, will not report it.

>>> print(re.match('super', 'superstition').span())
(0, 5)
>>> print(re.match('super', 'insuperable'))
None

On the other hand, will scan forward through the string,
reporting the first match it finds.

>>> print(re.search('super', 'superstition').span())
(0, 5)
>>> print(re.search('super', 'insuperable').span())
(2, 7)

Sometimes you’ll be tempted to keep using , and just add
to the front of your RE. Resist this temptation and use
instead. The regular expression compiler does some analysis of REs in order to
speed up the process of looking for a match. One such analysis figures out what
the first character of a match must be; for example, a pattern starting with
must match starting with a . The analysis lets the engine
quickly scan through the string looking for the starting character, only trying
the full match if a is found.

Adding defeats this optimization, requiring scanning to the end of the
string and then backtracking to find a match for the rest of the RE. Use
instead.

Greedy versus Non-Greedy

When repeating a regular expression, as in , the resulting action is to
consume as much of the pattern as possible. This fact often bites you when
you’re trying to match a pair of balanced delimiters, such as the angle brackets
surrounding an HTML tag. The naive pattern for matching a single HTML tag
doesn’t work because of the greedy nature of .

>>> s = '<html><head><title>Title</title>'
>>> len(s)
32
>>> print(re.match('<.*>', s).span())
(0, 32)
>>> print(re.match('<.*>', s).group())
<html><head><title>Title</title>

The RE matches the in , and the consumes the rest of
the string. There’s still more left in the RE, though, and the can’t
match at the end of the string, so the regular expression engine has to
backtrack character by character until it finds a match for the . The
final match extends from the in to the in
, which isn’t what you want.

In this case, the solution is to use the non-greedy qualifiers , ,
, or , which match as little text as possible. In the above
example, the is tried immediately after the first matches, and
when it fails, the engine advances a character at a time, retrying the
at every step. This produces just the right result:

>>> print(re.match('<.*?>', s).group())
<html>

(Note that parsing HTML or XML with regular expressions is painful.
Quick-and-dirty patterns will handle common cases, but HTML and XML have special
cases that will break the obvious regular expression; by the time you’ve written
a regular expression that handles all of the possible cases, the patterns will
be very complicated. Use an HTML or XML parser module for such tasks.)

Что сейчас востребовано, доступно для декретниц и приносит доход?

На сегодняшний день очень востребована и хорошо оплачиваема работа в сфере интернет-маркетинга:

Существует масса курсов удаленного обучения по этим профессиям. Если денег на платное образование нет, можете попробовать заработать деньги с помощью сервиса Workle или Яндекс.Толока.

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

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

Сопоставление с поиском

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

пример

#!/usr/bin/python3
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print ("search --> searchObj.group() : ", searchObj.group())
else:
   print ("Nothing found!!")

Когда приведенный выше код выполняется, он дает следующий результат —

No match!!
search --> matchObj.group() :  dogs

Функция match

Эта функция ищет в и поддерживает настройки с помощью дополнительного .
Ниже можно увидеть синтаксис данной функции:

Описание параметров:

№	Параметр & Описание
1	pattern — строка регулярного выражения ()
2	string — строка, в которой мы будем искать соответствие с шаблоном в начале строки ()
3	flags — модификаторы, перечисленными в таблице ниже. Вы можете указать разные флаги с помощью побитового OR

Функция возвращает объект при успешном завершении, или при ошибке. Мы используем функцию или объекта для получения результатов поиска.

№	Метод совпадения объектов и описание
1	group(num=0) — этот метод возвращает полное совпадение (или совпадение конкретной подгруппы)
2	groups() — этот метод возвращает все найденные подгруппы в tuple

Поиск доменных имен

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

Возьмем для примера такой текст:

<div class="reflist" style="list-style-type: decimal;"><ol class="references"><li id="cite_note-1"><span class="mw-cite-backlink"><b>^ (http://www.askoxford.com/concise_oed/train?view=uk). <i>(definition – Compact OED)</i>. Oxford University Press<span class="reference-accessdate">. Retrieved 2008-03-18</span>.</span><span title="ctx_ver=Z39.88-2004&rfr_id=info%3Asid%2Fen.wikipedia.org%3ATrain&rft.atitle=Train+%28noun%29&rft.genre=article&rft_id=http%3A%2F%2Fwww.askoxford.com%2Fconcise_oed%2Ftrain%3Fview%3Duk&rft.jtitle=%28definition+%E2%80%93+Compact+OED%29&rft.pub=Oxford+University+Press&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal" class="Z3988"><span style="display:none;"> </span></span></span></li><li id="cite_note-2"><span class="mw-cite-backlink"><b>^</b></span> <span class="reference-text"><span class="citation book">Atchison, Topeka and Santa Fe Railway (1948). <i>Rules: Operating Department</i>. p. 7.</span><span title="ctx_ver=Z39.88-2004&rfr_id=info%3Asid%2Fen.wikipedia.org%3ATrain&rft.au=Atchison%2C+Topeka+and+Santa+Fe+Railway&rft.aulast=Atchison%2C+Topeka+and+Santa+Fe+Railway&rft.btitle=Rules%3A+Operating+Department&rft.date=1948&rft.genre=book&rft.pages=7&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook" class="Z3988"><span style="display:none;"> </span></span></span></li><li id="cite_note-3"><span class="mw-cite-backlink"><b>^ (http://www.hydrogencarsnow.com/blog2/index.php/hydrogen-vehicles/i-hear-the-hydrogen-train-a-comin-its-rolling-round-the-bend/)</span></li><li id="cite_note-4"><span class="mw-cite-backlink"><b>^ (http://www.bnsf.com/media/news/articles/2008/01/2008-01-09a.html)</span></li><li id="cite_note-5"><span class="mw-cite-backlink"><b>^</b></span> <span class="reference-text"><span class="citation book">Central Japan Railway (2006). <i>Central Japan Railway Data Book 2006</i>. p. 16.</span><span title="ctx_ver=Z39.88-2004&rfr_id=info%3Asid%2Fen.wikipedia.org%3ATrain&rft.au=Central+Japan+Railway&rft.aulast=Central+Japan+Railway&rft.btitle=Central+Japan+Railway+Data+Book+2006&rft.date=2006&rft.genre=book&rft.pages=16&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook" class="Z3988"><span style="display:none;"> </span></span></span></li><li id="cite_note-6"><span class="mw-cite-backlink"><b>^ (http://web.archive.org/web/20080620033027/http://www.mrvc.indianrail.gov.in/overview.htm). _Official webpage of Mumbai Railway Vikas Corporation_. Archived from (http://www.mrvc.indianrail.gov.in/overview.htm) on 2008-06-20<span class="reference-accessdate">. Retrieved 2008-12-11</span>.</span><span title="ctx_ver=Z39.88-2004&rfr_id=info%3Asid%2Fen.wikipedia.org%3ATrain&rft.atitle=Overview+Of+the+existing+Mumbai+Suburban+Railway&rft.genre=article&rft_id=http%3A%2F%2Fwww.mrvc.indianrail.gov.in%2Foverview.htm&rft.jtitle=Official+webpage+of+Mumbai+Railway+Vikas+Corporation&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal" class="Z3988"><span style="display:none;"> </span></span></span></li></ol></div>

А нужно найти все основные домены в тексте

Как это сделать?

match=re.findall(r'http(s:|:)\/\/(www.|ww2.|)(*\.\w{2,3})',string)for elem in match:    print(elem)--------------------------------------------------------------------(':', 'www.', 'askoxford.com')(':', 'www.', 'hydrogencarsnow.com')(':', 'www.', 'bnsf.com')(':', '', 'web.archive.org')(':', 'www.', 'mrvc.indianrail.gov.in')(':', 'www.', 'mrvc.indianrail.gov.in')

| — здесь это оператор or, который возвращает наборы, содержащие паттерн внутри ().

Якоря

Для этого необходимо указать позицию матча.

Sr.No.	Пример и описание
1	^ Python Совпадение «Python» в начале строки или внутренней строки
2	Python $ Совпадение «Python» в конце строки или строки
3	\ APython Совпадение «Python» в начале строки
4	Python \ Z Совпадение «Python» в конце строки
5	\ bPython \ б Совпадение «Питон» на границе слова
6	\ brub \ B \ B является границей без слов: соответствует «rub» в «rube» и «ruby», но не в одиночку
7	Python (?! =) Совпадение «Python», если за ним следует восклицательный знак.
8	Python (? !!) Совпадение с «Питоном», если за ним не стоит восклицательный знак.

Поисковые системы

Как пользоваться ADB run

Шаблон регулярного выражения

Строка шаблона, используя специальный синтаксис для обозначения регулярное выражение:

Буквы и цифры сами. Регулярное выражение при букв и цифр совпадают ту же строку.

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

Пунктуация спасшемся только тогда, когда сам матч, или они представляют собой особый смысл.

Сам Backslash должен использовать побег символ обратной косой.

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

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

режим	описание
^	Соответствует началу строки
$	Соответствует концу строки.
,	Соответствует любому символу, кроме символа новой строки, если указан флаг re.DOTALL, вы можете соответствовать любому символу, включая символ новой строки.
	Он используется для представления группы символов, перечисленных отдельно: матч ‘а’, ‘т’ или ‘K’
	Не [] символов: соответствует в дополнение к а, Ь, с символами.
Re *	0 или более выражениям.
Re +	Один или более совпадающих выражений.
повторно?	Матч 0 или 1 по предшествующих регулярных выражений для определения сегментов, не жадный путь
Re {п}
повторно {п,}	Точное соответствие п предыдущего выражения.
Re {п, т}	Матч п в т раз по предшествующих регулярных выражений для определения сегментов, жадный путь
а | б	Совпадение или б
(Re)	Выражение матч G в скобках, также представляет собой группу
(? Imx)	Регулярное выражение состоит из трех дополнительных флагов: я, м, или х. Она влияет только на область в скобках.
(? -imx)	Регулярные выражения Закрыть я, м, или х необязательный флаг. Она влияет только на область в скобках.
(?: Re)	Аналогично (…), но не представляет собой группу,
(Imx 😕 Re)	Я использую в круглые скобки, м или х необязательный флаг
(-imx 😕 Re)	Не используйте I, M в круглых скобках, или х дополнительный флаг
(? # …)	Примечание.
(? = Re)	Форвард уверен разделитель. Если содержится регулярное выражение, представленное здесь …, успешно матчи в текущем местоположении, и не иначе. Тем не менее, как только содержала выражение была опробована, согласующий двигатель не продвигается, остальная часть узора даже попробовать разделителем правильно.
(?! Re)	Нападающий отрицанием разделителем. И, конечно, противоречит разделителем, успешным, когда содержащийся выражение не совпадает с текущей позиции в строке
(?> Re)	Независимый поиск по шаблону, устраняя откаты.
\ W	матч буквенно-цифровой
\ W	Матч не алфавитно-цифровой
\ S	Соответствует любой символ пробела, что эквивалентно .
\ S	Соответствует любой непустой символ
\ D	Соответствует любому количеству, которое эквивалентно .
\ D	Соответствует любому нечисловая
\ A	Соответствует началу строки
\ Z	Матч конец строки, если она существует символ новой строки, только до конца строки, чтобы соответствовать новой строки. с
\ Z	конец строки Match
\ G	Матч Матч завершен последнюю позицию.
\ B	Матчи границы слова, то есть, оно относится к месту и пробелы между словами. Например, ‘эр \ Ъ’ не может сравниться с «никогда» в «эр», но не может сравниться с «глаголом» в «эр».
\ B	Матч граница слова. ‘Er \ B’ может соответствовать «глагол» в «эр», но не может сравниться с «никогда» в «эр».
\ N, \ т, и тому подобное.	Соответствует новой строки. Соответствует символу табуляции. подождите
\ 1 … \ 9	Соответствующие подвыражения п-го пакета.
\ 10	Матч первые п пакетов подвыражению, если он после матча. В противном случае, выражение относится к восьмеричный код.

Notes on named capture groups

All capture groups have a group number, starting from 1.

Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.

The same name can be used by more than one group, with later captures ‘overwriting’ earlier captures. All of the captures of the group will be available from the captures method of the match object.

Group numbers will be reused across different branches of a branch reset, eg. (?|(first)|(second)) has only group 1. If capture groups have different group names then they will, of course, have different group numbers, eg. (?|(?P<foo>first)|(?P<bar>second)) has group 1 (“foo”) and group 2 (“bar”).

In the regex (\s+)(?|(?P<foo>+)|(\w+) (?P<foo>+) there are 2 groups:

• (\s+) is group 1.
• (?P<foo>+) is group 2, also called “foo”.
• (\w+) is group 2 because of the branch reset.
• (?P<foo>+) is group 2 because it’s called “foo”.

Поиск и замена

Модуль повторного Python предоставляет re.sub на матч замены строки.

Синтаксис:

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

Возвращаемая строка это строка с крайней левой RE матчей не будет повторяться, чтобы заменить. Если шаблон не найден, то символы будут возвращены без изменений.

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

Пример:

#!/usr/bin/python3
import re

phone = "2004-959-559 # 这是一个电话号码"

# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)

# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

电话号码 :  2004-959-559 
电话号码 :  2004959559

Методы объекта сопоставления Match:

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

Метод возвращает одну или несколько подгрупп совпадения. При наличии одного аргумента результатом будет одна строка, при наличии нескольких аргументов результатом будет кортеж с одним элементом на аргумент. Без аргументов группа 1 по умолчанию равна нулю — возвращается все совпадение.

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

>>> import re
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")

# Совпадение со всем шаблоном
>>> m.group()
# 'Isaac Newton'

# Первая группа
>>> m.group(1)
# 'Isaac'

# Вторая группа
>>> m.group(2)
# 'Newton'

# Можно указывать несколько групп
>>> m.group(1, 2)
# ('Isaac', 'Newton')

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

Умеренно сложный пример:

>>> import re
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
# 'Malcolm'
>>> m.group('last_name')
# 'Reynolds'

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

>>> m.group(1)
# 'Malcolm'
>>> m.group(2)
# 'Reynolds'

Если группа совпадает несколько раз, доступно только последнее совпадение:

>>> import re
>>> m = re.match(r"(..)+", "a1b2c3")

# 3 совпадения шаблона со строкой
>>> m.group()
# 'a1b2c3'

# для извлечения доступно только последнее
>>> m.group(1)
# 'c3'

Метод идентичен , что позволяет легче получить доступ к отдельной группе из объекта сопоставления:

>>> import re
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")

# полное совпадение
>>> m
'Isaac Newton'

# Первая заключенная в скобки подгруппа.
>>> m1
# 'Isaac'

# Вторая заключенная в скобки подгруппа.
>>> m2
# 'Newton'

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

>>> import re
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
# ('24', '1632')

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

>>> import re
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")

# 2 группа по умолчанию None.
>>> m.groups()
# ('24', None)

# теперь 2 группа по умолчанию '0'.
>>> m.groups('0')
# ('24', '0')

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

>>> import re
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
# {'first_name': 'Malcolm', 'last_name': 'Reynolds'}

, :

Методы возвращают индексы начала и конца подстроки совпадающей с группой . По умолчанию группа равна нулю, имеется в виду вся совпадающая подстрока. Методы возвращают , если группа существует, но не смогла захватить какой либо результат. Для объекта сопоставления и группы , которая внесла свой вклад в сопоставление, подстрока, сопоставленная группе эквивалентная , является:

m.stringm.start(g):m.end(g)]

Обратите внимание, что будет равно , если группа соответствует нулевой строке. Например после выполнения , будет равно 1, это 2

и равны 2, а вызывает исключение .

Пример, который удалит из адресов электронной почты:

>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email + emailm.end():]
# 'tony@tiger.net'

Метод вернет двойной кортеж вида

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

Часть 4. Некоторые полезные репозитории GitHub по программированию и машинному обучению

• Курс программирования на языке Python, основа сайта introtopython.org.
• «Data science IPython notebooks» — множество качественных тетрадок по основным библиотекам Python для анализа данных — NumPy, SciPy, Pandas, Matplotlib, Scikit-learn. Краткие обзоры Apache Spark и соревнования Kaggle «Titanic: Machine Learning from Disaster».
• Гарвардский курс анализа данных
• «Interactive coding challenges» — подборка основных задач на структуры данных, графы, сортировку, рекурсию и не только. Для многих задач приведены решения и поясняющий материал с картинками.
• Репозиторий Оливье Гризеля (одного из авторов библиотеки Scikit-learn) с обучающими тетрадками IPython. Еще один.
• Тьюториал по Scikit-learn, также от авторов
• Разбор задач курса Andrew Ng «Machine learning» на языке Python
• Материалы в дополнение к книге «Mining the Social Web (2nd Edition)» (Matthew A. Russell, издательство O’Reilly Media)
• Тьюториал по использованию ансамблей для решения задач Kaggle.
• Библиотека XGBoost, которая используется большинством победителей соревнований Kaggle. Там же можно познакомиться с их историями успеха. XGBoost хорош по качеству прогнозирования, эффективно реализован, хорошо параллелится.
• Подборка данных FiveThirtyEight. Просто куча интересных наборов данных.
• Прогнозирование результатов выборов в США. Хороший пример анализа данных с Pandas

re.compile

With the re.compile() function we can compile pattern into pattern objects,
which have methods for various operations such as searching for pattern matches
or performing string substitutions.

Let’s see two examples, using the re.compile() function.

The first example checks if the input from the user contains only letters,
spaces or . (no digits)

Any other character is not allowed.

The second example checks if the input from the user contains only numbers,
parentheses, spaces or hyphen (no letters)

Any other character is not allowed

The output of above script will be:

Please, enter your phone: s

Please enter your phone correctly!

It will continue to ask until you put in numbers only.

re module functions?

Function	Description
	Check if given pattern is present anywhere in input string
	Output is a object, usable in conditional expressions
	r-strings preferred to define RE
	Use byte pattern for byte input
	Python also maintains a small cache of recent RE
	ensures pattern matches the entire input string
	Compile a pattern for reuse, outputs object
	search and replace
	function with object as argument
	automatically escape all metacharacters
	split a string based on RE
	text matched by the groups will be part of the output
	portion matched by pattern outside group won’t be in output
	returns all the matches as a list
	if 1 capture group is used, only its matches are returned
	1+, each element will be tuple of capture groups
	portion matched by pattern outside group won’t be in output
	iterator with object for each match
	gives tuple of modified string and number of substitutions

The function definitions are given below:

Sets

A set is a set of characters inside a pair of square brackets with a special meaning:

Set	Description	Try it
	Returns a match where one of the specified characters (, , or ) are present	Try it »
	Returns a match for any lower case character, alphabetically between and	Try it »
	Returns a match for any character EXCEPT , , and	Try it »
	Returns a match where any of the specified digits (, , , or ) are present	Try it »
	Returns a match for any digit between and	Try it »
	Returns a match for any two-digit numbers from and	Try it »
	Returns a match for any character alphabetically between and , lower case OR upper case	Try it »
	In sets, , , , , , , has no special meaning, so means: return a match for any character in the string	Try it »

Matching Versus Searching

Python offers two different primitive operations based on regular expressions: match checks for a match only at the beginning of the string, while search checks for a match anywhere in the string (this is what Perl does by default).

Example

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"

When the above code is executed, it produces the following result −

No match!!
search --> searchObj.group() :  dogs

re.match

И следующий
метод

re.match(pattern,
string, flags)

который
определяет совпадение шаблона pattern в начале строки string с учетом флагов
flags (если они
указаны)

Обратите внимание, в отличие от метода search, который ищет
совпадение шаблона в любом месте строки, метод match смотрим
совпадение только вначале. Он возвращает объект совпадения re.Match, либо значение None, если шаблон не
был найден

Рассмотрим такой
пример. Пусть в строке ожидается номер телефона в формате:

+7(xxx)xxx-xx-xx

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

import re
 
text = "+7(123)456-78-90"
m = re.match(r"\+7\(\d{3}\)\d{3}-\d{2}-\d{2}", text)
print(m)

При запуске
программы получим объект совпадения:

<re.Match
object; span=(0, 16), match=’+7(123)456-78-90′>

Но, если вначале
строки добавить любой символ, то совпадение найдено не будет, т.к. метод match выполняет
анализ только сначала строки.

Regular Expression Modifiers: Option Flags

Regular expression literals may include an optional modifier to control various aspects of matching. The modifiers are specified as an optional flag. You can provide multiple modifiers using exclusive OR (|), as shown previously and may be represented by one of these −

Sr.No.	Modifier & Description
1	re.I Performs case-insensitive matching.
2	re.L Interprets words according to the current locale. This interpretation affects the alphabetic group (\w and \W), as well as word boundary behavior(\b and \B).
3	re.M Makes $ match the end of a line (not just the end of the string) and makes ^ match the start of any line (not just the start of the string).
4	re.S Makes a period (dot) match any character, including a newline.
5	re.U Interprets letters according to the Unicode character set. This flag affects the behavior of \w, \W, \b, \B.
6	re.X Permits «cuter» regular expression syntax. It ignores whitespace (except inside a set [] or when escaped by a backslash) and treats unescaped # as a comment marker.

Тип файла2Steam Game Backup File