RTFM && WTFN - backup

Темы:

• Основы
• Синтаксис

Для работы с регулярными выражениями в python используется модуль re.
В начале каждого скрипта его надо имортировать.

In [1]: import re

Модуль re поддерживает след. функции:

In [2]: re.           
            A           copyreg     enum        findall()   functools   L           match       RegexFlag   search      sre_parse   T           U           X           
            ASCII       DEBUG       error       finditer()  I           LOCALE      MULTILINE   S           split       sub         TEMPLATE    UNICODE                 
            compile()   DOTALL      escape()    fullmatch() IGNORECASE  M           purge       Scanner     sre_compile subn        template    VERBOSE                 

Самые часто используемые будут:

• search() - функция просматривает строку до первого совпадения. После того как обнаружили строку её уже можно печатть, форматировать и т.д.
• match() - функция просматривает строку с начала строки до первого совпадения. Если в начале строки нет совпадения, то функция возвращает None.

Пример:

In [8]: STR = 'dynamic-vpn                           0            2           0    permanent'
 
In [9]: MATCH = re.search('permanent', STR)
 
In [10]: MATCH
Out[10]: <_sre.SRE_Match object; span=(68, 77), match='permanent'>

В примере сделали:

• [8]: Объявили строку STR.
• [9]: Функцией search нашли в строке слово permanent.
• [10]: Информацию о найденном записали в MATCH.
  span=(68, 77) показывает номера символов строки где нашлось совпадение.
  match='permanent' показал, что совпало. Длина поля match в выводе ограничена, не весь вывод может поместиться.

• \d - любая цифра.
• \D - любой символ, кроме цифр.
• \s - специальные whitespace символы.
  Основные это табуляция, перевод строки и пробел.
  Есть еще вторые разновидности этих символов, \t\n\r\f\v, но на них можно забить.
• \S - все кроме whitespace символов.
• \w - любая буква или цифра полюс нижнее подчеркивание.
• \W - все, кроме букв или цифр.

Примеры:

\w\D+\S+\d - сначала идет одна любая буква или цифра, потом одна или более буква (плюс спец символы), далее один или более символов кроме whitespace и закончится совпадение должно одной цифрой.

In [145]: re.search('\w\D+\S+\d', L)
 
In [146]: L = '44w5'
 
In [147]: re.search('\w\D+\S+\d', L)
 
In [148]: 
 
In [148]: 
 
In [148]: L =  'a56c5-5b6'
 
In [149]: re.search('\w\D+\S+\d', L)
Out[149]: <_sre.SRE_Match object; span=(2, 9), match='6c5-5b6'>
 
In [150]: L =  'a56c5-56'
 
In [151]: re.search('\w\D+\S+\d', L)
Out[151]: <_sre.SRE_Match object; span=(2, 8), match='6c5-56'>
 
In [152]: L =  'ab3cd6'
 
In [153]: re.search('\w\D+\S+\d', L)
Out[153]: <_sre.SRE_Match object; span=(0, 6), match='ab3cd6'>
 
In [154]: L =  'a56c56'
 
In [155]: re.search('\w\D+\S+\d', L)
Out[155]: <_sre.SRE_Match object; span=(2, 6), match='6c56'>
 
In [156]: L =  'abc-_3'
 
In [157]: re.search('\w\D+\S+\d', L)
Out[157]: <_sre.SRE_Match object; span=(0, 6), match='abc-_3'>
 
In [158]: L =  'abc-_3a'
 
In [159]: re.search('\w\D+\S+\d', L)
Out[159]: <_sre.SRE_Match object; span=(0, 6), match='abc-_3'>
 
In [160]: L =  'abc-_a'
 
In [161]: re.search('\w\D+\S+\d', L)
 
In [162]: L =   'a36c'
 
In [163]: re.search('\w\D+\S+\d', L)

• regex+ - одно или более совпадение символа перед +
• regex* - ноль или более совпадений символа перед *
• regex? - ноль или одно совпадение символа.
• regex{5} - ровно 5 повторений символа перед {}.
• regex{2,4} - от 2 до 4 повторений символа перед {}.
• regex{7} - 7 и более повторений символа перед {}.

Примеры:
ab+b

In [27]: L = 'abbba'
 
In [28]: re.search('ab+b', L)
Out[28]: <_sre.SRE_Match object; span=(0, 4), match='abbb'>

ab*a

In [40]: L = 'aaaaa'
 
In [41]: re.search('ab*a', L)
Out[41]: <_sre.SRE_Match object; span=(0, 2), match='aa'>
 
In [44]: L = 'abababaaba'
 
In [45]: re.search('ab*a', L)
Out[45]: <_sre.SRE_Match object; span=(0, 3), match='aba'>

a?b+c* - в совпадении должны быть ноль или один символ ф (a?), один и более символов b (b+) и ноль или более символов с (с*).

In [118]: L = 'abbbabbb'
 
In [119]: re.search('a?b+c*', L)
Out[119]: <_sre.SRE_Match object; span=(0, 4), match='abbb'>

a{2}b{2,3}c{3,}

In [133]: L =   'aabbbccccc'
 
In [134]: re.search('a{2}b{2,3}c{3,}', L)
Out[134]: <_sre.SRE_Match object; span=(0, 10), match='aabbbccccc'>

• . - любой один символ.
• ^ - начало строки.
• $ - конец строки.
• [abc] - любой один символ в скобках.
• [a-e] - любой символ из диапазона a-e (a, b, c, d, e)
• [abc]+ - любая последовательность, состоящая из символов в скобках.
• [^abc] - любой один символ кроме тех, что указаны в скобках.
• b|c - один или второй элемент.

Примеры:
[abc]

In [111]: L = 'ecabababaaba'
 
In [112]: re.search('[abc]', L)
Out[112]: <_sre.SRE_Match object; span=(1, 2), match='c'>

[abc]+

In [58]: L = 'abababaaba'
 
In [59]: re.search('[abc]+', L)
Out[59]: <_sre.SRE_Match object; span=(0, 10), match='abababaaba'>

a.[b-d]+ - совпадение (не строка) должно начитаться с a, потом любой символ, потом любая последовательность символов содержащая b, c и d

In [69]: L =   'abbbabbb'
 
In [70]: re.search('a.[b-d]+', L)
Out[70]: <_sre.SRE_Match object; span=(0, 4), match='abbb'>

^a.[^b-d]+ - строка должна начитаться с a, потом любой символ, потом любая последовательность символов не содержащая b, c и d.

In [76]: L =  'abababaaba'
 
In [77]: re.search('^a.[^b-d]+', L)
Out[77]: <_sre.SRE_Match object; span=(0, 3), match='aba'>

^a.[b-d]+$ - строка должна начитаться с a, потом любой символ, потом любая последовательность символов содержащая b, c и d и потом сразу должен идти конец строки.

In [89]: L =  'abc'
 
In [90]: re.search('^a.[b-d]+$', L)
Out[90]: <_sre.SRE_Match object; span=(0, 3), match='abc'>

(ab|ac) - ab или ac.

In [105]: L = 'aabab'
 
In [106]: re.search('(ab|ac)', L)
Out[106]: <_sre.SRE_Match object; span=(1, 3), match='ab'>