Python.Модули.re

Всех приветствую! Сегодня у нас на рассмотрении модуль библиотеки Python3.6. Старался ничего не упустить. Думаю всем понятно и без слов, что такое регулярные выражения =)

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

.(точа) — в режиме по умолчанию удовлетворяет любому символу, кроме символа новой строки (’\n’). Если был задан флаг DOTALL, удовлетворяет любому символу, включая символ новой строки.

^ — в режиме по умолчанию удовлетворяет началу строки. Если был задан флаг MULTILINE, также удовлетворяет пустой строке сразу после символа новой строки.

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

* — удовлетворяет наибольшему возможному количеству (0 или более) фрагментов строки, удовлетворяющих выражению. Например, выражению ’ab*’ удовлетворяют строки ’a’, ’ab’, ’abb’ и т. д.

+ — удовлетворяет наибольшему возможному количеству (1 или более) фрагментов строки, удовлетворяющих выражению. Например, выражению ’ab+’ удовлетворяют строки ’ab’, ’abb’ и т. д., но не удовлетворяет строка ’a’.

? — удовлетворяет наибольшему возможному количеству (0 или 1) фрагментов строки, удовлетворяющих выражению atom. Например, выражению ’ab?’ удовлетворяют строки ’a’ и ’ab’.

*? — удовлетворяет наименьшему возможному количеству (0 или более) фрагментов строки, удовлетворяющих выражению. Например, регулярное выражение ’<.*>’ удовлетворяет всей строке ’<H1>title</H1>’, в то время как ’<.*?>’ удовлетворяет только ’<H1>’.

+? — удовлетворяет наименьшему возможному количеству (1 или более) фрагментов строки, удовлетворяющих выражению.

?? — удовлетворяет наименьшему возможному количеству (0 или 1) фрагментов строки, удовлетворяющих выражению.

{m} — указывает, что точно m копий предыдущего RE должны быть сопоставлены, меньше совпадений приводит к тому, что весь RE не будет соответствовать. Например, a{6} будет соответствовать ровно шести символам 'a', но не пять.

{m,n} — заставляет результирующий RE соответствовать от m до n повторений предыдущего RE, пытаясь сопоставить как можно больше повторений. Например: a{3,5} будет соответствовать от 3 до 5 символов 'a'. Опускание m указывает нижнюю границу нуля, а опущение n указывает бесконечную верхнюю границу. В качестве примера, a{4,}b будет соответствовать «aaaab» или тысячам символов «a», за которыми следует «b», но не «aaab». Запятая не может быть опущена или модификатор будет путать с ранее описанной формой.

{m,n}? — заставляет результирующий RE соответствовать от m до n повторений предыдущего RE, пытаясь сопоставить как можно меньше повторений. Это не жадная версия предыдущего квалификатора. Например, в 6-символьной строке 'aaaaaa', a{3,5} будет соответствовать 5 символам 'a', а a{3,5}? будет соответствовать только 3 символам.

\ — либо экранирует специальные символы (позволяя вам сопоставлять символы, такие как «*», «?» и т.д.) Или сигнализирует о специальной последовательности. Специальные последовательности обсуждаются ниже.

[] — используется для описания множества символов. Например:

• Выражению ’[ab?]’ удовлетворяют символы ’a’, ’b’ и ’?’;
• Выражению ’[a-z]’ — все строчные буквы латинского алфавита;
• Выражению ’[azA-Z0-9]’ — все буквы латинского алфавита и цифры;
• Если Вы хотите включить в множество символ ‘]’ или ‘-’, поместите его первыми или используйте символ обратной косой черты: ’[]]’, r’[]\-]’;
• Символ ‘^’ в множестве наоборот, не должен идти первым, должен быть единственным символом в множестве или записанным с использованием обратной косой черты. В противном случае будет искать символы не входящие в данное множество символов.

строка|строка — удовлетворяет строкам, одной из сторон, где строка - произвольное регулярное выражение. Будет использовано первое из них, при котором все регулярное удовлетворяет строке.

(...) — делает выражение в скобках “неделимым” и образует группу. Фрагмент строки, удовлетворяющий группе в данном контексте, может быть извлечен после выполнения операции сопоставления, а также может быть использован далее в этом же регулярном выражении с помощью специальной последовательности r’\number’.

(?...) — такая запись не образует группу и не используется для сопоставления, а лишь устанавливает опции для всего регулярного выражения.

(?aiLmsux) — пример предыдущей записи, который соответствует флагам IGNORECASE, LOCALE, MULTILINE, DOTALL, UNICODE, TEMPLATE и VERBOSE. Может быть полезна, если Вы хотите включить флаги в регулярное выражение вместо того, чтобы передавать их функции compile().

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

(?imsx-imsx:...) — (Ноль или несколько букв из набора «i», «m», «s», «x», необязательно сопровождаемое «-», за которым следуют одна или несколько букв из одного и того же набора.) Буквы устанавливают или удаляют соответствующие флаги : re.I (игнорировать регистр), re.M (многострочный), re.S (соответствует любому символу) и re.X (verbose), для части выражения.

(?P<name>...) — работает аналогично записи ’()’ и, кроме того, делает доступным фрагмент строки, удовлетворяющий выражению, через имя name, то есть делает группу именованной. Имя группы должно быть корректным идентификатором языка Python. Именованные группы так же, как и обычные, нумеруются и доступны через запись r’\number’.

(?P=name) — удовлетворяет тексту, который ранее удовлетворил выражению, указанному в группе с именем name.

(?#...) — комментарий, игнорируется.

(?=...) — удовлетворяет пустой строке, но только если за ней следует текст, удовлетворяющий выражению. Например, выражению ’Александр (?=Пушкин)’ удовлетворяет фрагмент ’Александр ’ в строке ’Александр Пушкин’.

(?!...) — удовлетворяет пустой строке, но только если за ней следует текст, который не удовлетворяет выражению. Например, выражению ’Александр (?!Пушкин)’ удовлетворяет фрагмент ’Александр ’ в строке ’Александр Сергеевич Пушкин’, но не в строке ’Александр Пушкин’.

(?<=...) — удовлетворяет пустой строке, но только если перед ней следует текст, который удовлетворяет выражению. Например, выражению ’(?<=abc)def’ удовлетворяет фрагмент ’def’ в строке ’abcdef’. Выражение должно всегда удовлетворять строке одной длины. Например, Вы можете использовать ’abc’ или ’a|b’, но не ’a*’.

(?<!...) — удовлетворяет пустой строке, но только если перед ней следует текст, который не удовлетворяет выражению. Выражение должно всегда удовлетворять строке одной длины. Например, Вы можете использовать ’abc’ или ’a|b’, но не ’a*’.

(?(id/name)yes-pattern|no-pattern) — будет пытаться соответствовать yes-pattern, если группа с заданным id или name существует и без шаблона, если это не так. no-pattern необязателен и может быть опущен. Например, (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) - плохой шаблон сопоставления электронной почты, который будет соответствовать '<user@host.com>', а также 'user@host.com', но не с '<user@host.com' и 'user@host.com>'.

Специальные последовательности

\number — удовлетворяет содержимому группы с номером number. Группы нумеруются с 1. Например, выражению r'(.+) \1' удовлетворяют строки ’the the’ и ’55 55’, но не удовлетворяет строка ’the end’. Эта специальная последовательность может быть использована для ссылок на группы с номерами до 99. Если в числе number первая цифра 0, number содержит три восьмеричные цифры или последовательность содержится в определении множества (’[]’), такая специальная последовательность будет интерпретироваться как символ с восьмеричным кодом number.

\A — удовлетворяет только началу строки.

\b — удовлетворяет пустой строке в начале или конце слова. Слово определяется как последовательность из букв, цифр и символов подчеркивания. В определении множества (’[]’) последовательность r'\b' для совместимости с литеральными выражениями Python интерпретируется как символ возврата на одну позицию (BS).

\B — удовлетворяет пустой строке в середине слова.

\d — удовлетворяет любой десятичной цифре, эквивалентна множеству ’[0-9]’. При использовании флага LOCALE или UNICODE удовлетворяет символу, который в данном языке или в базе данных Unicode считается десятичной цифрой.

\D — удовлетворяет любому символу, не являющемуся десятичной цифрой; эквивалентна множеству ’[^0-9]’. При использовании флага LOCALE или UNICODE удовлетворяет символу, который в данном языке или в базе данных Unicode не считается десятичной цифрой.

\s — удовлетворяет любому символу пропуска (whitespace), эквивалентна множеству r'[\t\n\v\f\r ]'. При использовании флага LOCALE или UNICODE удовлетворяет символу, который в данном языке или в базе данных Unicode считается символом пропуска.

\S — удовлетворяет любому символу, не являющемуся символом пропуска (whitespace), эквивалентна множеству r'[^\t\n\v\f\r ]'.При использовании флага LOCALE или UNICODE удовлетворяет символу, который в данном языке или в базе данных Unicode не считается символом пропуска.

\w — удовлетворяет любому символу, являющемуся буквой, цифрой или символом подчеркивания. Если не был установлен флаг LOCALE, эквивалентна множеству ’[a-zA-Z0-9_]’. С установленным флагом LOCALE или UNICODE удовлетворяет символу подчеркивания и символу, который в данном языке или в базе данных Unicode считается буквой или цифрой.

\W — удовлетворяет любому символу, не входящему в класс r'\w', то есть эквивалентна множеству r'^\w'.

\Z — удовлетворяет только концу строки.

Функции, константы

re.compile(pattern, flags=0) — компилирует регулярное выражение в строке pattern и возвращает представляющий его объект. Поведением регулярного выражения можно управлять с помощью аргумента flags. Значение аргумента flags может быть составлено из описанных ниже констант с помощью оператора |.

re.A, re.ASCII

Флаг ASCII указывает Python сопоставлять против ASCII, вместо использования полного Юникода для сопоставления, в сочетании со следующими кодами: w, W, b, B, d, D, s и S. Также существует флаг re.U / re.UNICODE, который используется в целях обратной совместимости. В любом случае, эти флаги являются излишеством, так как Python выполняет сопоставления в Юникоде в автоматическом режиме.

re.DEBUG

Данный флаг показывает информацию о дебаге вашего скомпилированного выражения.

re.I, re.IGNORECASE

Используется, если необходимо выполнить сопоставление или поиск без учета регистра букв. Использование этого флага совместно с флагом LOCALE в версиях интерпретатора 1.5.2 и более ранних бессмысленно, а иногда (если используемая кодировка не является надмножеством ASCII) и опасно.

re.L, re.LOCALE

Делает классы r'\w', r'\W', r'\b' и r'\B' зависящими от текущих национальных установок (используются национальные установки на момент выполнения операции сопоставления или поиска, а не компиляции регулярного выражения).

re.M, re.MULTILINE

Устанавливает многострочный режим, в котором специальные символы ’^’ (только при выполнении поиска) и ’$’ (при выполнении как сопоставления, так и поиска) удовлетворяют не только началу и концу строки, но и сразу после и перед символом ’\n’ соответственно.

re.S, re.DOTALL

Делает специальный символ ’.’ удовлетворяющим любому символу. Без этого флага ’.’ удовлетворяет любому символу, кроме ’\n’.

re.X, re.VERBOSE

Использование этого флага позволяет писать регулярные выражения в более элегантном виде:

• Символы пропуска (whitespace) в строке-шаблоне игнорируются, за исключением определений множеств и записанных с использованием обратной косой черты.
• Все символы до конца строки после ‘#’, за исключением случаев, когда ‘#’ содержится в определении множества или записан с использованием обратной косой черты (r’\#’), считаются комментарием и игнорируются.

re.search(pattern, string, flags=0) — ищет в строке string позицию, в которой она удовлетворяет регулярному выражению pattern и возвращает объект, представляющий результат сопоставления. Если такая позиция не найдена, возвращает None.

re.match(pattern, string, flags=0) — если 0 или более символов в начале строки string удовлетворяют регулярному выражению pattern, возвращает объект, представляющий результат сопоставления, в противном случае возвращает None.

re.fullmatch(pattern, string, flags=0) — если вся строка соответствует шаблону регулярного выражения, вернёт соответствующий объект соответствия. Вернёт None, если строка не соответствует шаблону.

re.split(pattern, string, maxsplit=0, flags=0) — разбивает строку string в местах, удовлетворяющих регулярному выражению pattern и возвращает результат в виде списка. Если pattern содержит группирующие скобки, то текст групп также включается в возвращаемый список. Если задан и не равен 0 аргумент maxsplit, выполняется не более maxsplit расщеплений и остаток строки помещается в конец списка.

re.findall(pattern, string, flags=0) — возвращает список непересекающихся фрагментов строки string, удовлетворяющих регулярному выражению pattern. Если pattern содержит группы, элементами списка будут строки, удовлетворяющие группе, или кортеж строк, если групп в шаблоне несколько. Результаты сопоставления с нулевой длиной также включаются в результат.

re.finditer(pattern, string, flags=0) — Верните итератор, дающий объекты соответствия по всем совпадениям совпадений для шаблона RE в строке. Строка сканируется слева направо, а совпадения возвращаются в найденном порядке. Пустые совпадения включаются в результат, если они не касаются начала другого матча.

re.sub(pattern, repl, string, count=0, flags=0) — возвращает строку, полученную заменой непересекающихся фрагментов строки string, удовлетворяющих регулярному выражению pattern, на repl. Если не найдено ни одного такого фрагмента, строка возвращается неизменной. repl может быть строкой или функцией. Функция должна воспринимать один аргумент — объект, представляющий результат сопоставления, и возвращать строку для замены.

re.subn(pattern, repl, string, count=0, flags=0) — выполняет те же самые операции, что и функция sub(), но возвращает кортеж, состоящий из новой строки и числа произведенных замен.

re.escape(pattern) — возвращает регулярное выражение, пригодное для поиска вхождений строки string, то есть записывает с использованием обратной косой черты символы строки, имеющие специальное значение в регулярных выражения.

re.purge() — очищает кэш регулярных выражений.

exception re.error(msg, pattern=None, pos=None) — класс исключений, которые генерируются, если используемое регулярное выражение содержит ошибки (например, несоответствие группирующих скобок), а также при возникновении некоторых других ошибок. Несоответствие строки шаблону никогда не является ошибкой.

msg — неформатированное сообщение об ошибке.

pattern — образец регулярного выражения.

pos — индекс в шаблоне, где сбой компиляции (может быть None).

lineno — строка, соответствующая pos (может быть None).

colno — столбец, соответствующий pos (может быть None).

Объекты, представляющие регулярные выражения

regex.search(string[, pos[, endpos]]) — ищет в строке string позицию, в которой она удовлетворяет регулярному выражению и возвращает объект, представляющий результат сопоставления. Если такая позиция не найдена, возвращает None. Необязательные аргументы pos и endpos имеют такое же значение, как и для метода match(), описанного ниже.

regex.match(string[, pos[, endpos]]) — если 0 или более символов в начале строки string удовлетворяют регулярному выражению, возвращает объект, представляющий результат сопоставления, в противном случае возвращает None.

Необязательный аргумент pos (по умолчанию равен 0) указывает позицию в строке, начиная с которой необходимо выполнять сопоставление. Использование этого аргумента не эквивалентно вызову метода для string[pos:], так как в первом случае специальные последовательности ’^’ и r'\A' удовлетворяют началу реальной строки. Аналогично аргумент endpos указывает позицию в строке, до которой будет выполняться сопоставление.

regex.fullmatch(string[, pos[, endpos]]) — аналогична функции match(), но требует,что бы весь текст совпал с шаблоном, а не только его начало

regex.split(string, maxsplit=0) — вызов этого метода эквивалентен вызову функции split() с объектом, представляющим регулярное выражение, в качестве первого аргумента.

regex.findall(string[, pos[, endpos]]) — вызов этого метода эквивалентен вызову функции findall() с объектом, представляющим регулярное выражение, в качестве первого аргумента.

regex.finditer(string[, pos[, endpos]]) — аналогична функции findall(), но возвращает не список, а итератор.

regex.sub(repl, string, count=0) — вызов этого метода эквивалентен вызову функции sub() с объектом, представляющим регулярное выражение, в качестве первого аргумента.

regex.subn(repl, string, count=0) — вызов этого метода эквивалентен вызову функции subn() с объектом, представляющим регулярное выражение, в качестве первого аргумента.

regex.flags — значение аргумента flags, переданного функции compile() при компиляции объекта. Этот атрибут не отражает флаги, установленные с помощью специальных последовательностей в самом регулярном выражении.

regex.groups — метод возвращает все соответствующие подгруппы в кортеже (None, если не найдено)

regex.groupindex — словарь, отображающий имена групп к их номерам (пустой, если регулярное выражение не содержит именованных групп).

regex.pattern — строка, содержащая регулярное выражение, которое было использовано при компиляции объекта.

Объекты, представляющие результат сопоставления

match.expand(template) — в шаблоне template заменяет специальные последовательности, ссылающиеся на символы (например, ‘\n’) и удовлетворяющие фрагменты объекта (‘\1’, ‘\g<1>’, ‘\g<name>’) аналогично методу sub() и возвращает результат.

match.group([group1, ...]) — возвращает один или более фрагментов, которые при выполнении операции сопоставления удовлетворили определениям одной или нескольких групп. Числа groupN указывают на группы с номерами от 1 до 99 или на фрагмент, удовлетворяющий всему регулярному выражению (группа с номером 0). groupN может быть также именем группы, заданной в регулярном выражении с помощью синтаксиса ’?P<name>expr’. Если шаблон не содержит группы с указанным номером (именем), генерируется исключение IndexError.

match.__getitem__(g) — соответствует match.group(g).

match.groups(default=None) — возвращает кортеж из фрагментов, которые при выполнении операции сопоставления удовлетворили определениям всех групп, содержащихся в регулярном выражении. default используются в качестве значения по умолчанию для групп, которые не удовлетворяют никакому фрагменту. Если аргумент default не задан, в таких случаях всегда используется None.

match.groupdict(default=None) — возвращает словарь, отображающий имена групп к фрагментам, которым эти группы удовлетворяют. default используется в качестве значения по умолчанию для групп, которые не удовлетворяют никакому фрагменту. Если аргумент default не задан, в таких случаях всегда используется None.

match.start([group]), match.end([group]) — возвращает позиции начала и конца фрагмента в исходной строке, который удовлетворяет группе с номером (или именем) group (по умолчанию используется 0, что соответствует всему регулярному выражению). Если группа не удовлетворяют никакому фрагменту, возвращают -1. Фрагмент, удовлетворяющий группе g, то есть m.group(g), может быть также получен как m.string[m.start(g):m.end(g)].

match.span([group]) — возвращает кортеж ‘(m.start(group), m.end(group))’, где m - объект, к которому применяется метод. Обратите внимание, что, если группа не удовлетворяют никакому фрагменту, метод возвращает ‘(-1, -1)’.

match.pos — значение аргумента pos, переданного функции (методу) search() или match().

match.endpos — значение аргумента endpos, переданного функции (методу) search() или match().

match.lastindex — номер последней удовлетворенной группы (наиболее охватывающей) или None, если не была удовлетворена ни одна группа.

match.lastgroup — имя последней удовлетворенной группы (наиболее охватывающей) или None, если эта группа не имеет имени или не была удовлетворена ни одна группа.

match.re — объект компилированного регулярного выражения, который использовался для выполнения операции поиска или сопоставления.

match.string — значение аргумента string, переданного функции (методу) search() или match().

Примеры

match функция:

#!/usr/bin/python
import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

Вывод:

matchObj.group() : Cats are smarter than dogs

matchObj.group(1) : Cats

matchObj.group(2) : smarter

search функция:

#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

Вывод:

searchObj.group() : Cats are smarter than dogs

searchObj.group(1) : Cats

searchObj.group(2) : smarter

Соответствие и поиск:

#!/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!!"

Вывод:

No match!!

search --> matchObj.group() : dogs

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

#!/usr/bin/python
import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)    
print "Phone Num : ", num

Вывод:

Phone Num : 2004-959-559

Phone Num : 2004959559