re — Regular expression operations¶
This module provides regular expression matching operations similar to those found in Perl.
Both patterns and strings to be searched can be Unicode strings ( str ) as well as 8-bit strings ( bytes ). However, Unicode strings and 8-bit strings cannot be mixed: that is, you cannot match a Unicode string with a byte pattern or vice-versa; similarly, when asking for a substitution, the replacement string must be of the same type as both the pattern and the search string.
Regular expressions use the backslash character ( ‘\’ ) to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write ‘\\\\’ as the pattern string, because the regular expression must be \\ , and each backslash must be expressed as \\ inside a regular Python string literal. Also, please note that any invalid escape sequences in Python’s usage of the backslash in string literals now generate a DeprecationWarning and in the future this will become a SyntaxError . This behaviour will happen even if it is a valid escape sequence for a regular expression.
The solution is to use Python’s raw string notation for regular expression patterns; backslashes are not handled in any special way in a string literal prefixed with ‘r’ . So r"\n" is a two-character string containing ‘\’ and ‘n’ , while "\n" is a one-character string containing a newline. Usually patterns will be expressed in Python code using this raw string notation.
It is important to note that most regular expression operations are available as module-level functions and methods on compiled regular expressions . The functions are shortcuts that don’t require you to compile a regex object first, but miss some fine-tuning parameters.
The third-party regex module, which has an API compatible with the standard library re module, but offers additional functionality and a more thorough Unicode support.
Regular Expression Syntax¶
A regular expression (or RE) specifies a set of strings that matches it; the functions in this module let you check if a particular string matches a given regular expression (or if a given regular expression matches a particular string, which comes down to the same thing).
Regular expressions can be concatenated to form new regular expressions; if A and B are both regular expressions, then AB is also a regular expression. In general, if a string p matches A and another string q matches B, the string pq will match AB. This holds unless A or B contain low precedence operations; boundary conditions between A and B; or have numbered group references. Thus, complex expressions can easily be constructed from simpler primitive expressions like the ones described here. For details of the theory and implementation of regular expressions, consult the Friedl book [Frie09] , or almost any textbook about compiler construction.
A brief explanation of the format of regular expressions follows. For further information and a gentler presentation, consult the Regular Expression HOWTO .
Regular expressions can contain both special and ordinary characters. Most ordinary characters, like ‘A’ , ‘a’ , or ‘0’ , are the simplest regular expressions; they simply match themselves. You can concatenate ordinary characters, so last matches the string ‘last’ . (In the rest of this section, we’ll write RE’s in this special style , usually without quotes, and strings to be matched ‘in single quotes’ .)
Some characters, like ‘|’ or ‘(‘ , are special. Special characters either stand for classes of ordinary characters, or affect how the regular expressions around them are interpreted.
Repetition operators or quantifiers ( * , + , ? ,
The special characters are:
(Dot.) In the default mode, this matches any character except a newline. If the DOTALL flag has been specified, this matches any character including a newline.
(Caret.) Matches the start of the string, and in MULTILINE mode also matches immediately after each newline.
Matches the end of the string or just before the newline at the end of the string, and in MULTILINE mode also matches before a newline. foo matches both ‘foo’ and ‘foobar’, while the regular expression foo$ matches only ‘foo’. More interestingly, searching for foo.$ in ‘foo1\nfoo2\n’ matches ‘foo2’ normally, but ‘foo1’ in MULTILINE mode; searching for a single $ in ‘foo\n’ will find two (empty) matches: one just before the newline, and one at the end of the string.
Causes the resulting RE to match 0 or more repetitions of the preceding RE, as many repetitions as are possible. ab* will match ‘a’, ‘ab’, or ‘a’ followed by any number of ‘b’s.
Causes the resulting RE to match 1 or more repetitions of the preceding RE. ab+ will match ‘a’ followed by any non-zero number of ‘b’s; it will not match just ‘a’.
Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. ab? will match either ‘a’ or ‘ab’.
The ‘*’ , ‘+’ , and ‘?’ quantifiers are all greedy; they match as much text as possible. Sometimes this behaviour isn’t desired; if the RE <.*> is matched against ‘<a> b <c>’ , it will match the entire string, and not just ‘<a>’ . Adding ? after the quantifier makes it perform the match in non-greedy or minimal fashion; as few characters as possible will be matched. Using the RE <.*?> will match only ‘<a>’ .
Like the ‘*’ , ‘+’ , and ‘?’ quantifiers, those where ‘+’ is appended also match as many times as possible. However, unlike the true greedy quantifiers, these do not allow back-tracking when the expression following it fails to match. These are known as possessive quantifiers. For example, a*a will match ‘aaaa’ because the a* will match all 4 ‘a’ s, but, when the final ‘a’ is encountered, the expression is backtracked so that in the end the a* ends up matching 3 ‘a’ s total, and the fourth ‘a’ is matched by the final ‘a’ . However, when a*+a is used to match ‘aaaa’ , the a*+ will match all 4 ‘a’ , but when the final ‘a’ fails to find any more characters to match, the expression cannot be backtracked and will thus fail to match. x*+ , x++ and x?+ are equivalent to (?>x*) , (?>x+) and (?>x?) correspondingly.
New in version 3.11.
Specifies that exactly m copies of the previous RE should be matched; fewer matches cause the entire RE not to match. For example, a <6>will match exactly six ‘a’ characters, but not five.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible. For example, a <3,5>will match from 3 to 5 ‘a’ characters. Omitting m specifies a lower bound of zero, and omitting n specifies an infinite upper bound. As an example, a<4,>b will match ‘aaaab’ or a thousand ‘a’ characters followed by a ‘b’ , but not ‘aaab’ . The comma may not be omitted or the modifier would be confused with the previously described form.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as few repetitions as possible. This is the non-greedy version of the previous quantifier. For example, on the 6-character string ‘aaaaaa’ , a <3,5>will match 5 ‘a’ characters, while a<3,5>? will only match 3 characters.
Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible without establishing any backtracking points. This is the possessive version of the quantifier above. For example, on the 6-character string ‘aaaaaa’ , a<3,5>+aa attempt to match 5 ‘a’ characters, then, requiring 2 more ‘a’ s, will need more characters than available and thus fail, while a<3,5>aa will match with a <3,5>capturing 5, then 4 ‘a’ s by backtracking and then the final 2 ‘a’ s are matched by the final aa in the pattern. x
New in version 3.11.
Either escapes special characters (permitting you to match characters like ‘*’ , ‘?’ , and so forth), or signals a special sequence; special sequences are discussed below.
If you’re not using a raw string to express the pattern, remember that Python also uses the backslash as an escape sequence in string literals; if the escape sequence isn’t recognized by Python’s parser, the backslash and subsequent character are included in the resulting string. However, if Python would recognize the resulting sequence, the backslash should be repeated twice. This is complicated and hard to understand, so it’s highly recommended that you use raw strings for all but the simplest expressions.
Used to indicate a set of characters. In a set:
Characters can be listed individually, e.g. [amk] will match ‘a’ , ‘m’ , or ‘k’ .
Ranges of characters can be indicated by giving two characters and separating them by a ‘-‘ , for example [a-z] will match any lowercase ASCII letter, [0-5][0-9] will match all the two-digits numbers from 00 to 59 , and [0-9A-Fa-f] will match any hexadecimal digit. If — is escaped (e.g. [a\-z] ) or if it’s placed as the first or last character (e.g. [-a] or [a-] ), it will match a literal ‘-‘ .
Special characters lose their special meaning inside sets. For example, [(+*)] will match any of the literal characters ‘(‘ , ‘+’ , ‘*’ , or ‘)’ .
Character classes such as \w or \S (defined below) are also accepted inside a set, although the characters they match depends on whether ASCII or LOCALE mode is in force.
Characters that are not within a range can be matched by complementing the set. If the first character of the set is ‘^’ , all the characters that are not in the set will be matched. For example, [^5] will match any character except ‘5’ , and [^^] will match any character except ‘^’ . ^ has no special meaning if it’s not the first character in the set.
To match a literal ‘]’ inside a set, precede it with a backslash, or place it at the beginning of the set. For example, both [()[\]<>] and []()[<>] will match a right bracket, as well as left bracket, braces, and parentheses.
Support of nested sets and set operations as in Unicode Technical Standard #18 might be added in the future. This would change the syntax, so to facilitate this change a FutureWarning will be raised in ambiguous cases for the time being. That includes sets starting with a literal ‘[‘ or containing literal character sequences ‘—‘ , ‘&&’ , ‘
‘ , and ‘||’ . To avoid a warning escape them with a backslash.
Changed in version 3.7: FutureWarning is raised if a character set contains constructs that will change semantically in the future.
A|B , where A and B can be arbitrary REs, creates a regular expression that will match either A or B. An arbitrary number of REs can be separated by the ‘|’ in this way. This can be used inside groups (see below) as well. As the target string is scanned, REs separated by ‘|’ are tried from left to right. When one pattern completely matches, that branch is accepted. This means that once A matches, B will not be tested further, even if it would produce a longer overall match. In other words, the ‘|’ operator is never greedy. To match a literal ‘|’ , use \| , or enclose it inside a character class, as in [|] .
Matches whatever regular expression is inside the parentheses, and indicates the start and end of a group; the contents of a group can be retrieved after a match has been performed, and can be matched later in the string with the \number special sequence, described below. To match the literals ‘(‘ or ‘)’ , use \( or \) , or enclose them inside a character class: [(] , [)] .
This is an extension notation (a ‘?’ following a ‘(‘ is not meaningful otherwise). The first character after the ‘?’ determines what the meaning and further syntax of the construct is. Extensions usually do not create a new group; (?P<name>. ) is the only exception to this rule. Following are the currently supported extensions.
(One or more letters from the set ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ .) The group matches the empty string; the letters set the corresponding flags: re.A (ASCII-only matching), re.I (ignore case), re.L (locale dependent), re.M (multi-line), re.S (dot matches all), re.U (Unicode matching), and re.X (verbose), for the entire regular expression. (The flags are described in Module Contents .) This is useful if you wish to include the flags as part of the regular expression, instead of passing a flag argument to the re.compile() function. Flags should be used first in the expression string.
Changed in version 3.11: This construction can only be used at the start of the expression.
A non-capturing version of regular parentheses. Matches whatever regular expression is inside the parentheses, but the substring matched by the group cannot be retrieved after performing a match or referenced later in the pattern.
(Zero or more letters from the set ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ , optionally followed by ‘-‘ followed by one or more letters from the ‘i’ , ‘m’ , ‘s’ , ‘x’ .) The letters set or remove the corresponding flags: re.A (ASCII-only matching), re.I (ignore case), re.L (locale dependent), re.M (multi-line), re.S (dot matches all), re.U (Unicode matching), and re.X (verbose), for the part of the expression. (The flags are described in Module Contents .)
The letters ‘a’ , ‘L’ and ‘u’ are mutually exclusive when used as inline flags, so they can’t be combined or follow ‘-‘ . Instead, when one of them appears in an inline group, it overrides the matching mode in the enclosing group. In Unicode patterns (?a. ) switches to ASCII-only matching, and (?u. ) switches to Unicode matching (default). In byte pattern (?L. ) switches to locale depending matching, and (?a. ) switches to ASCII-only matching (default). This override is only in effect for the narrow inline group, and the original matching mode is restored outside of the group.
New in version 3.6.
Changed in version 3.7: The letters ‘a’ , ‘L’ and ‘u’ also can be used in a group.
Attempts to match . as if it was a separate regular expression, and if successful, continues to match the rest of the pattern following it. If the subsequent pattern fails to match, the stack can only be unwound to a point before the (?>. ) because once exited, the expression, known as an atomic group, has thrown away all stack points within itself. Thus, (?>.*). would never match anything because first the .* would match all characters possible, then, having nothing left to match, the final . would fail to match. Since there are no stack points saved in the Atomic Group, and there is no stack point before it, the entire expression would thus fail to match.
New in version 3.11.
Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name. Group names must be valid Python identifiers, and each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named.
Операторы и выражения¶
Большинство предложений (логических строк) в программах содержат выражения. Простой пример выражения: 2 + 3 . Выражение можно разделить на операторы и операнды.
Операторы — это некий функционал, производящий какие-либо действия, который может быть представлен в виде символов, как например + , или специальных зарезервированных слов. Операторы могут производить некоторые действия над данными, и эти данные называются операндами. В нашем случае 2 и 3 — это операнды.
Операторы¶
Кратко рассмотрим операторы и их применение:
Обратите внимание, вычислить значения выражений, данных в примерах, можно также используя интерпретатор интерактивно. Например, для проверки выражения 2 + 3 воспользуйтесь интерактивной командной строкой интерпретатора Python:
Операторы и их применение
Краткая запись математических операций и присваивания¶
Зачастую результат проведения некой математической операции необходимо присвоить переменной, над которой эта операция производилась. Для этого существуют краткие формы записи выражений:
Вы можете записать:
Обратите внимание, что выражения вида » переменная = переменная операция выражение » принимает вид » переменная операция = выражение «.
Порядок вычисления¶
Если имеется выражение вида 2 + 3 * 4 , что производится раньше: сложение или умножение? Школьный курс математики говорит нам, что умножение должно производиться в первую очередь. Это означает, что оператор умножения имеет более высокий приоритет, чем оператор сложения.
Следующая таблица показывает приоритет операторов в Python, начиная с самого низкого (самое слабое связывание) и до самого высокого (самое сильное связывание). Это означает, что в любом выражении Python сперва вычисляет операторы и выражения, расположенные внизу таблицы, а затем операторы выше по таблице.
Эта таблица взята из Справочника по языку Python (англ.) и приводится здесь для полноты описания. На практике лучше использовать скобки для группировки операторов и операндов, чтобы в явном виде указать порядок вычисления выражений. Заодно это облегчит чтение программы. Более подробно см. в разделе Изменение порядка вычисления ниже.
Приоритет операторов
Операторы, о которых мы не упомянули, будут объяснены в дальнейших главах.
В этой таблице операторы с равным приоритетом расположены в одной строке. Например, + и — имеют равный приоритет.
Изменение порядка вычисления¶
Для облегчения чтения выражений можно использовать скобки. Например, 2 + (3 * 4) определённо легче понять, чем 2 + 3 * 4 , которое требует знания приоритета операторов. Как и всё остальное, скобки нужно использовать разумно (не перестарайтесь) и избегать излишних, как в (2 + (3 * 4)) .
Есть ещё одно преимущество в использовании скобок — они дают возможность изменить порядок вычисления выражений. Например, если сложение необходимо произвести прежде умножения, можно записать нечто вроде (2 + 3) * 4 .
Ассоциативность¶
Операторы обычно обрабатываются слева направо. Это означает, что операторы с равным приоритетом будут обработаны по порядку от левого до правого. Например, 2 + 3 + 4 обрабатывается как (2 + 3) + 4 .
Выражения¶
Пример (сохраните как expression.py ):
Вывод:
Как это работает:
Длина и ширина прямоугольника хранятся в переменных length и breadth соответственно. Мы используем их для вычисления периметра и площади прямоугольника при помощи выражений. Результат выражения length * breadth сохраняется в переменной area , после чего выводится на экран функцией print . Во втором случае мы напрямую подставляем значение выражения 2 * (length + breadth) в функцию print .
Также обратите внимание, как Python «красиво печатает» результат. Несмотря на то, что мы не указали пробела между ‘Площадь равна’ и переменной area , Python подставляет его за нас, чтобы получить красивый и понятный вывод. Программа же остаётся при этом легкочитаемой (поскольку нам не нужно заботиться о пробелах между строками, которые мы выводим). Это пример того, как Python облегчает жизнь программисту.
Резюме¶
Мы увидели, как пользоваться операторами, операндами и выражениями. Это основные строительные блоки любой программы. Далее мы увидим, как это применить на практике.
«True» — англ. «Верно (Правда)»; «False» — англ. «Ошибочно (Ложь)». (прим. перев.) ↩
re — Операции с регулярными выражениями¶
Модуль предоставляет операции сопоставления регулярных выражений, аналогичные тем, что есть в Perl.
И шаблоны, и строки для поиска могут быть строками Юникод ( str ), а также 8-битными строками ( bytes ). Однако строки Юникод и 8-битные строки нельзя смешивать: то есть вы не можете сопоставить строку Юникод с байтовым шаблоном или наоборот; аналогично, при запросе замены, строка замены должна быть того же типа, что и шаблон, и строка поиска.
В регулярных выражениях используется обратная косая черта ( ‘\’ ) для обозначения специальных форм или для разрешения использования специальных символов без указания их особого значения. Это противоречит тому, что Python использует тот же символ для той же цели в строковых литералах; например, чтобы сопоставить буквальную обратную косую черту, можно было бы написать ‘\\\\’ в качестве строки шаблона, потому что регулярное выражение должно быть \\ , а каждая обратная косая черта должна быть выражена как \\ внутри обычного строкового литерала Python. Также обратите внимание, что любые недопустимые escape-последовательности при использовании Python обратной косой черты в строковых литералах теперь генерируют DeprecationWarning , а в будущем он станет SyntaxError . Такое поведение произойдет, даже если это допустимая escape-последовательность для регулярного выражения.
Решение состоит в том, чтобы использовать нотацию необработанных Python строк для шаблонов регулярных выражений; обратные косые черты не обрабатываются каким-либо особым образом в строковом литерале с префиксом ‘r’ . Таким образом, r»\n» — это двухсимвольная строка, содержащая ‘\’ и ‘n’ , а «\n» — это односимвольная строка, содержащая новую строку. Обычно шаблоны выражаются в коде Python с использованием данной нотации необработанных строк.
Важно отметить, что большинство операций с регулярными выражениями доступны как функции и методы уровня модуля для скомпилированных регулярных выражений . Функции представляют собой ярлыки, которые не требуют предварительной компиляции объекта регулярного выражения, но пропускают некоторые параметры точной настройки.
Сторонний модуль regex, у которого API, совместимое с модулем стандартной библиотеки re , но предлагает дополнительные функции и более полную поддержку Юникода.
Синтаксис регулярных выражений¶
Регулярное выражение (или RE) определяет набор строк, которые ему соответствуют; функции в этом модуле позволяют проверить, соответствует ли строка заданному регулярному выражению (или соответствует ли данное регулярное выражение определенной строке, что сводится к тому же самому).
Регулярные выражения можно объединять в новые регулярные выражения; если A и B являются регулярными выражениями, то AB также является регулярным выражением. В общем, если строка p соответствует A, а другая строка q соответствует B, строка pq будет соответствовать AB. Это верно, если A или B не содержат операций с низким приоритетом; граничные условия между A и B; или иметь пронумерованные групповые ссылки. Таким образом, сложные выражения можно легко построить из более простых примитивных выражений, подобных рассмотренным далее. За подробностями теории и реализации регулярных выражений обратитесь к книге Фридла [Frie09] или почти в любом учебнике по построению компиляторов.
Далее следует краткое объяснение формата регулярных выражений. Для получения дополнительной информации и более мягкого знакомства обратитесь к HOWTO по регулярным выражениям .
Регулярные выражения могут содержать как специальные, так и обычные символы. Большинство обычных символов, таких как ‘A’ , ‘a’ или ‘0’ , являются простейшими регулярными выражениями; они просто соответствуют самим себе. Вы можете объединять обычные символы, поэтому last соответствует строке ‘last’ . (В оставшейся части этого раздела мы будем писать RE в специальном стиле , обычно без кавычек, а сопоставляемые строки ‘в одинарных кавычках’ .)
Некоторые символы, например ‘|’ или ‘(‘ , являются специальными. Специальные символы обозначают классы обычных символов или влияют на интерпретацию окружающих их регулярных выражений.
Квалификаторы повторения ( * , + , ? ,
. (Точка). В режиме по умолчанию это соответствует любому символу, кроме новой строки. Если указан флаг DOTALL , он соответствует любому символу включая новую строку. ^ (Каретка.) Соответствует началу строки, а также в режиме MULTILINE соответствует сразу после каждой новой строки. $ Соответствует концу строки или непосредственно перед новой строкой в конце строки, а в режиме MULTILINE также соответствует перед новой строкой. foo соответствует как «foo», так и «foobar», а регулярное выражение foo$ соответствует только «foo». Что ещё интереснее, поиск foo.$ в ‘foo1\nfoo2\n’ обычно соответствует «foo2», но и «foo1» в режиме MULTILINE ; поиск одного $ в ‘foo\n’ найдёт два (пустых) совпадения: одно непосредственно перед переводом строки и одно в конце строки. * Заставляет результирующий RE соответствовать 0 или более повторениям предыдущего RE, как можно больше повторений. ab* будет соответствовать следующим буквам «a», «ab» или «a» любому количеству букв «b». + Заставляет результирующий RE соответствовать 1 или более повторениям предыдущего RE. ab+ будет соответствовать «a», за которым следует любое ненулевое количество «b»; оно не будет просто совпадать с «а». ? Заставляет результирующий RE соответствовать 0 или 1 повторению предыдущего RE. ab? будет соответствовать либо «a», либо «ab». *? , +? , ?? Все квалификаторы ‘*’ , ‘+’ и ‘?’ — жадные; они захватывают как можно больше текста. Иногда такое поведение нежелательно; если RE <.*> совпадает с ‘<a> b <c>’ , оно будет соответствовать всей строке, а не только ‘<a>’ . Добавление ? после квалификатора переключает это сопоставление в режим не жадный или минимальный; по возможности будет сопоставлено минимальное кол-во символов. Использование RE <.*?> будет соответствовать только ‘<a>’ .
Либо экранирует специальные символы (позволяя вам сопоставлять такие символы, как ‘*’ , ‘?’ и т. д.) или сигнализирует особую последовательность; специальные последовательности обсуждаются ниже.
Если вы не используете необработанную строку для выражения шаблона, помните, что Python также использует обратную косую черту как escape- последовательность в строковых литералах; если escape-последовательность не распознаётся парсером Python, обратная косая черта и последующий символ включаются в результирующую строку. Однако, если Python распознает полученную последовательность, обратную косую черту следует повторить дважды. Это сложно и трудно понять, поэтому настоятельно рекомендуется использовать необработанные строки для всех, кроме простейших выражений.
Используется для обозначения набора (множества) символов. В множестве:
Символы могут быть перечислены индивидуально, например [amk] будет соответствовать ‘a’ , ‘m’ или ‘k’ .
Диапазоны символов можно указать, задав два символа и разделив их ‘-‘ , например [a-z] будет соответствовать любой строчной букве ASCII, [0-5][0-9] будет соответствовать всем двузначным числам от 00 до 59 , а [0-9A-Fa-f] будет соответствовать любой шестнадцатеричной цифре. Если — экранирован (например, [a\-z] ) или если он помещён в качестве первого или последнего символа (например, [-a] или [a-] ), он будет соответствовать литералу ‘-‘ .
Специальные символы теряют свое особое значение внутри наборов. Например, [(+*)] будет соответствовать любому из литеральных символов ‘(‘ , ‘+’ , ‘*’ или ‘)’ .
- Классы символов, такие как \w или \S (определенные ниже), также принимаются внутри набора, хотя соответствующие им символы зависят от того, активен ли режим ASCII или LOCALE .
- Символы, которые не входят в диапазон, могут быть сопоставлены дополняя набор. Если первый символ набора — ‘^’ , все символы, которых нет в множестве, будут сопоставлены. Например, [^5] будет соответствовать любому символу, кроме ‘5’ , а [^^] будет соответствовать любому символу, кроме ‘^’ . ^ не имеет особого значения, если это не первый символ в множестве.
- Чтобы соответствовать литералу ‘]’ внутри набора, поставьте перед ним обратную косую черту или поместите его в начало набора. Например, и [()[\]<>] , и []()[<>] будут соответствовать круглой скобке.
Изменено в версии 3.7: Появляется FutureWarning , если набор символов содержит конструкции, которые будут семантически изменяться в будущем.
(Ноль или более букв из набора ‘a’ , ‘i’ , ‘L’ , ‘m’ , ‘s’ , ‘u’ , ‘x’ , после них необязательно следует ‘-‘ , за которым следует одна или несколько букв из ‘i’ , ‘m’ , ‘s’ , ‘x’ .) Буквы устанавливают или снимают соответствующие флажки: re.A (соответствие только ASCII), re.I (без учёта регистра) , re.L (зависеть от локали), re.M (многострочный) , re.S (точка соответствует всему), re.U (Юникод соответствие) и re.X (подробный) для части выражения. (Флаги рассмотрены в Содержание модуля .)
Буквы ‘a’ , ‘L’ и ‘u’ являются взаимоисключающими при использовании в качестве встроенных флагов, поэтому их нельзя объединены или следовать за ‘-‘ . Вместо этого, когда один из них появляется во встроенной группе, он отменяет режим сопоставления во включающей группе. В Юникод шаблонах (?a. ) переключается на сопоставление только ASCII, а (?u. ) переключается на Юникод сопоставление (по умолчанию). В байтовом шаблоне (?L. ) переключается на соответствие в зависимости от локали, а (?a. ) переключается на соответствие только ASCII (по умолчанию). Это переопределение действует только для узкой встроенной группы, и исходный режим сопоставления восстанавливается за пределами группы.
Добавлено в версии 3.6.
Изменено в версии 3.7: Символы ‘a’ , ‘L’ и ‘u’ также могут использоваться в группе.
Подобно обычным круглым скобкам, но соответствует подстроке группы доступный через символическое имя группы name. Имена групп должны быть действительными Python идентификаторами, и каждое имя группы должно быть определено только один раз в регулярном выражении. Символическая группа также является пронумерованной группой, как если бы группа не была названа.
На именованные группы можно ссылаться в трёх контекстах. Если шаблон — (?P<quote>[‘»]).*?(?P=quote) (т. е. соответствует строке, заключенной в одинарные или двойные кавычки):
- (?P=quote) (как показано)
- \1
- m.group(‘quote’)
- m.end(‘quote’) (и т. д.)
- \g<quote>
- \g<1>
- \1
Соответствует, если текущей позиции в строке предшествует совпадение для . , которое заканчивается в текущей позиции. Это называется положительное прогнозируемое утверждение. (?<=abc)def найдёт совпадение в ‘abcdef’ , поскольку при просмотре назад будет выполнено резервное копирование 3 символов и проверяется, совпадает ли содержащийся шаблон. Содержащийся шаблон должен соответствовать только строкам некоторой фиксированной длины, что означает, что abc или a|b разрешены, а a* и a <3,4>— нет. Обратите внимание, что шаблоны, которые начинаются с положительного прогнозируемого утверждения, не будут совпадать в начале поисковой строки; вы, скорее всего, захотите использовать функцию search() , а не функцию match() :
В этом примере выполняется поиск слова после дефиса:
Изменено в версии 3.5: Добавлена поддержка групповых ссылок фиксированной длины.
Специальные последовательности состоят из ‘\’ и символа из списка ниже. Если обычный символ не является цифрой ASCII или буквой ASCII, то результирующий RE будет соответствовать второму символу. Например, \$ соответствует символу ‘$’ .
\number Соответствует содержимому группы с таким же номером. Группы пронумерованы начиная с 1. Например, (.+) \1 соответствует ‘the the’ или ’55 55′ , но не ‘thethe’ (обратите внимание на пробел после группы). Это особая последовательность может использоваться только для соответствия одной из первых 99 групп. Если первая цифра number равна 0 или number состоит из трех восьмеричных цифр, оно не будет интерпретировано как групповое совпадение, но как символ с восьмеричным number. Внутри ‘[‘ и ‘]’ символьного класса, все числовые escape-символы обрабатываются как символы. \A Соответствует только началу строки. \b
Соответствует пустой строке, но только в начале или в конце слова. Слово определяется как последовательность символов слова. Отметим, что формально \b определяется как граница между символом \w и \W (или наоборот), или между \w и началом/концом строки. Это означает, что r’\bfoo\b’ соответствует ‘foo’ , ‘foo.’ , ‘(foo)’ , ‘bar foo baz’ , но не ‘foobar’ или ‘foo3’ .
По умолчанию в Юникод шаблонах используются буквенно-цифровые Юникод символы, но это можно изменить с помощью флага ASCII . Границы слов определяются текущей локалью, если используется флаг LOCALE . Внутри диапазона символов \b представляет backspace символ для совместимости со строковыми литералами Python.
\B Соответствует пустой строке, но только если она не находится в начале или конце слова. Это означает, что r’py\B’ соответствует ‘python’ , ‘py3’ , ‘py2’ , но не ‘py’ , ‘py.’ или ‘py!’ . \B — полная противоположность \b , поэтому символы слова в Юникод шаблонах представляют собой буквенно-цифровые символы Юникода или знак подчеркивания, хотя это возможно можно изменить с помощью флага ASCII . Границы слов определяются текущей локалью, если используется флаг LOCALE . \d Для Юникод (str) шаблонов: Соответствует любой десятичной цифре Юникода (то есть любому символу в категории символов Юникода [Nd]). Сюда входят [0-9] и также многие другие цифровые символы. Если установлен флаг ASCII будут производиться только [0-9] совпадения. Для 8-разрядных (байтовых) шаблонов: Соответствует любой десятичной цифре; эквивалентно [0-9] . \D Соответствует любому символу, кроме десятичной цифры. Это противоположность \d . Если используется флаг ASCII , то становится эквивалентом [^0-9] . \s Для Юникод (str) шаблонов: Соответствует пробельным символам Юникода (включая [ \t\n\r\f\v] , а также многие другие символы, например неразрывные пробелы, предусмотренные правилами во многих языках). Если используется флаг ASCII будет совпадение для [ \t\n\r\f\v] . Для 8-разрядных (байтовых) шаблонов: Соответствует символам, считающихся пробельными в множестве символов ASCII; это эквивалентно [ \t\n\r\f\v] . \S Соответствует любому символу, кроме символа пробела. Это противоположность \s . Если используется флаг ASCII , то это становится эквивалентом [^ \t\n\r\f\v] . \w Для Юникод (str) шаблонов: Соответствует символам Юникод слова; включает в себя большинство символов которые могут быть частью слова на любом языке, а также числа и подчеркивание. Если используется флаг ASCII , будет совпадение для [a-zA-Z0-9_] . Для 8-разрядных (байтовых) шаблонов: Соответствует символам, считающимся буквенно-цифровыми в наборе символов ASCII; это эквивалентно [a-zA-Z0-9_] . Если используется флаг LOCALE , то будут сопоставляться символы, считающиеся буквенно-цифровыми в текущей локали, а также подчеркивание. \W Соответствует любому символу, кроме словесного. Это противоположность \w . Если используется флаг ASCII становится эквивалентом [^a-zA-Z0-9_] . Если используется флаг LOCALE , то будут сопоставляться символы, считающиеся буквенно-цифровыми в текущей локали, но не подчеркивание. \Z Соответствует только концу строки.
Большинство стандартных экранирований, поддерживаемых строковыми литералами Python, также принимаются анализатором регулярных выражений:
(Обратите внимание, что \b используется для представления границ слова и означает «возврат» только внутри классов символов.)
Управляющие последовательности ‘\u’ , ‘\U’ и ‘\N’ распознаются только в Юникод шаблонах. В байтовых шаблонах это ошибки. Неизвестные escape- последовательности букв ASCII зарезервированы для использования в будущем и рассматриваются как ошибки.
Восьмеричные escape-последовательности включены в ограниченной форме. Если первая цифра — 0, или если есть три восьмеричных цифры, это считается восьмеричным escape-символом. В противном случае это групповая ссылка. Что касается строковых литералов, восьмеричные escape-последовательности всегда имеют длину не более трёх цифр.
Изменено в версии 3.3: Добавлены escape-последовательности ‘\u’ и ‘\U’ .
Изменено в версии 3.6: Неизвестные escape-последовательности, состоящие из ‘\’ и буквы ASCII, теперь являются ошибками.
Изменено в версии 3.8: Добавлена escape-последовательность ‘\N
Содержание модуля¶
Модуль определяет несколько функций, констант и исключение. Некоторые функции являются упрощенными версиями полнофункциональных методов для скомпилированных регулярных выражений. Большинство нетривиальных приложений всегда используют скомпилированную форму.
Изменено в версии 3.6: Константы флагов теперь являются экземплярами RegexFlag , который является подклассом enum.IntFlag .
Скомпилировать шаблон регулярного выражения в объект регулярного выражения , который можно использовать для сопоставления с помощью match() , search() и других методов, рассмотренных далее.
Поведение выражения можно изменить, указав значение flags. Значения могут быть любыми из следующих переменных, объединенных с помощью побитового ИЛИ (оператор | ).
но использование re.compile() и сохранение полученного объекта регулярного выражения для повторного использования более эффективно, когда выражение будет использоваться несколько раз в одной программе.
Скомпилированные версии самых последних шаблонов, переданные в re.compile() , и функции сопоставления на уровне модуля кэшируются, поэтому программам, использующим только несколько регулярных выражений одновременно, не нужно беспокоиться о компиляции регулярных выражений.
Сделать так, чтобы \w , \W , \b , \B , \d , \D , \s и \S выполняли сопоставление только ASCII вместо полного Юникод сопоставления. Имеет значение только для Юникод шаблонов и игнорируется для байтовых шаблонов. Соответствует встроенному флагу (?a) .
Обратите внимание, что для обратной совместимости флаг re.U всё ещё существует (а также его синоним re.UNICODE и его встроенный аналог (?u) ), но они избыточны в Python 3, поскольку совпадения по умолчанию для Юникод строк (а Юникод сопоставление не разрешено для байтов).
Показать отладочную информацию о скомпилированном выражении. Нет соответствующего встроенного флага.
re. I ¶ re. IGNORECASE ¶
Выполнять сопоставление без учёта регистра; такие выражения, как [A-Z] , также будут соответствовать строчным буквам. Полное соответствие Юникоду (например, Ü , соответствующее ü ) также работает, если только флаг re.ASCII не используется для отключения совпадений, отличных от ASCII. Текущая локаль не изменяет действие этого флага, если также не используется флаг re.LOCALE . Соответствует встроенному флагу (?i) .
Обратите внимание, что когда Юникод шаблоны [a-z] или [A-Z] используются в сочетании с флагом IGNORECASE , они будут соответствовать 52 буквам ASCII и 4 дополнительным буквам, отличным от ASCII: „İ“ (U+0130, заглавная латинская буква I с точкой выше), „ı“ (U+0131, латинская строчная буква без точки i), „ſ“ (U+017F, латинская строчная буква длинная s) и „K“ (U+212A, знак кельвина). Если используется флаг ASCII , сопоставляются только буквы от «a» до «z» и от «A» до «Z».
re. L ¶ re. LOCALE ¶
Сделать \w , \W , \b , \B и сопоставлять без учёта регистра в зависимости от текущей локали. Флаг можно использовать только с байтовыми шаблонами. Использование этого флага не рекомендуется, поскольку механизм локали очень ненадёжен, он обрабатывает только одну «культуру» за раз и работает только с 8-битными языковыми стандартами. Соответствие Юникоду уже включено по умолчанию в Python 3 для Юникод (str) шаблонов, и оно может обрабатывать различные локали/языки. Соответствует встроенному флагу (?L) .
Изменено в версии 3.6: re.LOCALE может использоваться только с байтовыми шаблонами и несовместим с re.ASCII .
Изменено в версии 3.7: Скомпилированные объекты регулярных выражений с флагом re.LOCALE больше не зависят от локали во время компиляции. Только локаль во время сопоставления влияет на результат сопоставления.
Если указано, шаблонный символ ‘^’ соответствует началу строки и началу каждой строки (сразу после каждой новой строки); шаблонный символ ‘$’ соответствует концу строки и в конце каждой строки (непосредственно перед каждой новой строкой). По умолчанию ‘^’ соответствует только в начале строки, а ‘$’ только в конце строки и непосредственно перед новой строкой (если есть) в конце строки. Соответствует встроенному флагу (?m) .
re. S ¶ re. DOTALL ¶
Сделать так, чтобы специальный символ ‘.’ соответствовал любому символу, включая перевод строки; без этого флага ‘.’ будет соответствовать чему угодно, кроме новой строки. Соответствует встроенному флагу (?s) .
re. X ¶ re. VERBOSE ¶
Флаг позволяет вам писать выглядящие лучше и удобнее для чтения регулярные выражения, позволяя визуально разделять логические части шаблона и добавлять комментарии. Пробелы в шаблоне игнорируются, кроме тех случаев, когда они находятся в классе символов, или когда им предшествует неэкранированная обратная косая черта, или внутри токенов, например: *? , (?: или (?P<. > . Когда строка содержит не принадлежащий к классу символов # и которому не предшествует неэкранированная обратная косая черта, все символы от самого левого такого # до конца строки игнорируются.
Это означает, что два следующих объекта регулярного выражения, соответствующие десятичному числу, функционально равны:
Соответствует встроенному флагу (?x) .
Сканирует string в поисках первого места, где pattern регулярного выражения даёт совпадение, и возвращает соответствующий объект соответствия . Возвращает None , если ни одна позиция в строке не соответствует шаблону; обратите внимание, что функция отличается от поиска совпадения нулевой длины в некоторой точке строки.
Если ноль или более символов в начале string соответствуют pattern регулярного выражения; возвращает соответствующий объект сопоставления . Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.
Обратите внимание, что даже в режиме MULTILINE re.match() будет соответствовать только началу строки, а не в начале каждой строки.
Если вы хотите найти совпадение в любом месте string, используйте вместо неё search() (см. также search() против match() ).
Если вся string соответствует pattern регулярного выражения, возвращает соответствующий объект сопоставления . Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.
Добавлено в версии 3.4.
Разделить string по экземплярам pattern. Если в шаблоне используются захватывающие круглые скобки, то текст всех групп в pattern также возвращается как часть результирующего списка. Если maxsplit отличен от нуля, происходит не более maxsplit разбиений, а остаток строки возвращается как последний элемент списка.
Если в разделителе есть группы захвата, и он соответствует началу строки, результат будет начинаться с пустой строки. То же самое и с концом строки:
Таким образом, компоненты-разделители всегда находятся по одним и тем же относительным индексам в списке результатов.
Пустые совпадения для шаблона разделяют строку, только если она не находится рядом с предыдущим пустым совпадением.
Изменено в версии 3.1: Добавлен необязательный аргумент flags.
Изменено в версии 3.7: Добавлена поддержка разделения по шаблону, который может соответствовать пустой строке.
Возвращает все неперекрывающиеся совпадения pattern в string в виде списка строк. string просматривается слева направо, и совпадения возвращаются в найденном порядке. Если в шаблоне присутствует одна или несколько групп, возвращает список групп; это будет список кортежей, если в шаблоне больше одной группы. В результат включаются пустые совпадения.
Изменено в версии 3.7: Непустые совпадения теперь могут начинаться сразу после предыдущего пустого совпадения.
Возвращает итератор , отдающий объекты сопоставления по всем неперекрывающимся совпадениям для pattern RE в string. string просматривается слева направо, и совпадения возвращаются в найденном порядке. В результат включаются пустые совпадения.
Изменено в версии 3.7: Непустые совпадения теперь могут начинаться сразу после предыдущего пустого совпадения.
Возвращает строку, полученную заменой крайних левых неперекрывающихся вхождений pattern в string с заменой repl. Если шаблон не найден, string возвращается без изменений. repl может быть строкой или функцией; если это строка, то в ней обрабатываются любые escape-символы. Т. е. \n преобразуется в одиночный символ новой строки, \r преобразуется в возврат каретки и т. д. Неизвестные escape-последовательности букв ASCII зарезервированы для использования в будущем и рассматриваются как ошибки. Другие неизвестные escape-символы, например, \& , остаются в покое. Обратные ссылки, такие как \6 , заменяются подстрокой, соответствующей группе 6 в шаблоне. Например:
Если repl — функция, она вызывается для каждого неперекрывающегося вхождения pattern. Функция принимает единственный аргумент объект сопоставления и возвращает заменяющую строку. Например:
Шаблон может быть строкой или объектом шаблона .
Необязательный аргумент count — это максимальное количество замен шаблона; count должно быть неотрицательным целым числом. Если пропущено или равно нулю, все вхождения будут заменены. Пустые совпадения для шаблона заменяются только тогда, когда они не находятся рядом с предыдущим пустым совпадением, поэтому sub(‘x*’, ‘-‘, ‘abxd’) возвращает ‘-a-b— d-‘ .
В аргументах repl строкового типа, помимо экранирования символов и обратных ссылок, рассмотренных выше, \g<name> будет использовать подстроку, соответствующую группе с именем name , как определено синтаксисом (?P<name>. ) . \g<number> использует соответствующий номер группы; следовательно, \g<2> эквивалентен \2 , но не является двусмысленным в замене, такой как \g<2>0 . \20 будет интерпретироваться как ссылка на группу 20, а не как ссылку на группу 2, за которой следует буквальный символ ‘0’ . Обратная ссылка \g<0> заменяет всю подстроку, совпадающую с RE.
Изменено в версии 3.1: Добавлен необязательный аргумент flags.
Изменено в версии 3.5: Несовпадающие группы заменяются пустой строкой.
Изменено в версии 3.6: Неизвестные escape-последовательности в pattern, состоящем из ‘\’ и буквы ASCII, теперь являются ошибками.
Изменено в версии 3.7: Неизвестные escape-последовательности в repl, состоящем из ‘\’ и буквы ASCII, теперь являются ошибками.
Изменено в версии 3.7: Пустые совпадения для шаблона заменяются рядом с предыдущим непустым совпадением.
Выполняет ту же операцию, что и sub() , но возвращает кортеж (new_string, number_of_subs_made) .
Изменено в версии 3.1: Добавлен необязательный аргумент flags.
Изменено в версии 3.5: Несовпадающие группы заменяются пустой строкой.
Экранирование (Escape) специальных символов в pattern. Это полезно, если вы хотите сопоставить произвольную литеральную строку, которая может содержать метасимволы регулярного выражения. Например:
Эту функцию нельзя использовать для заменяющей строки в sub() и subn() , следует экранировать только обратную косую черту. Например:
Изменено в версии 3.3: Символ ‘_’ больше не экранируется.
Изменено в версии 3.7: Экранируются только символы, которые могут иметь особое значение в регулярном выражении. В результате ‘!’ , ‘»‘ , ‘%’ , «‘» , ‘,’ , ‘/’ , ‘:’ , ‘;’ , ‘<‘ , ‘=’ , ‘>’ , ‘@’ и «`» больше не экранируются.
Очистить кеш регулярных выражений.
Возникает исключение, если переданная строка одной из функций указанных здесь, не является допустимым регулярным выражением (например, она может содержать несовпадающие круглые скобки) или когда во время компиляции или сопоставления возникает другая ошибка. Если строка не содержит совпадения с шаблоном, это никогда не будет ошибкой. Экземпляр ошибки содержит следующие дополнительные атрибуты:
Неформатированное сообщение об ошибке.
Шаблон регулярного выражения.
Индекс в pattern, в котором произошла ошибка компиляции (может быть None ).
Строка, соответствующая pos (может быть None ).
Столбец, соответствующий pos (может быть None ).
Изменено в версии 3.5: Добавлены дополнительные атрибуты.
Объекты регулярных выражений¶
Скомпилированные объекты регулярного выражения поддерживают следующие методы и атрибуты:
Pattern. search ( string [ , pos [ , endpos ] ] ) ¶
Просканировать string в поисках первого места, где регулярное выражение даёт совпадение, и возвращает соответствующий объект сопоставления . Возвращает None , если ни одна позиция в строке не соответствует шаблону; обратите внимание, что это отличается от поиска совпадения нулевой длины в некоторой точке строки.
Необязательный второй параметр pos задает индекс в строке, с которой должен начинаться поиск; по умолчанию это 0 . Это не полностью эквивалентно нарезке строки; символ шаблона ‘^’ соответствует реальному началу строки и позициям сразу после новой строки, но не обязательно по индексу, с которого должен начинаться поиск.
Необязательный параметр endpos ограничивает глубину поиска в строке; это будет выглядеть так, как если бы строка состояла из символов endpos, поэтому поиск совпадения будет выполняться только для символов от pos до endpos — 1 . Если endpos меньше pos, совпадение не будет найдено; в противном случае, если rx является скомпилированным объектом регулярного выражения, rx.search(string, 0, 50) эквивалентен rx.search(string[:50], 0) .
Если этому регулярному выражению соответствует ноль или более символов в начале string, возвращает соответствующий объект сопоставления . Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.
Необязательные параметры pos и endpos имеют то же значение, что и для метода search() .
Если вы хотите найти совпадение в любом месте string, используйте вместо него search() (см. также search() против match() ).
Pattern. fullmatch ( string [ , pos [ , endpos ] ] ) ¶
Если вся string соответствует этому регулярному выражению, возвращает соответствующий объект сопоставления . Возвращает None , если строка не соответствует шаблону; обратите внимание, что это отличается от совпадения нулевой длины.
Необязательные параметры pos и endpos имеют то же значение, что и для метода search() .
Добавлено в версии 3.4.
Идентичен функции split() с использованием скомпилированного шаблона.
Pattern. findall ( string [ , pos [ , endpos ] ] ) ¶
Подобно функции findall() , использующей скомпилированный шаблон, но также принимает дополнительные параметры pos и endpos, которые ограничивают область поиска, как для search() .
Pattern. finditer ( string [ , pos [ , endpos ] ] ) ¶
Аналогично функции finditer() , использующей скомпилированный шаблон, но также принимает дополнительные параметры pos и endpos, которые ограничивают область поиска, как для search() .
Идентичен функции sub() , с использованием скомпилированного шаблона.
Идентично функции subn() с использованием скомпилированного шаблона.
Флаги соответствия регулярному выражению. Это комбинация флагов, присвоенных compile() , любых встроенных флагов (. ) в шаблоне и неявных флагов, таких как UNICODE , если шаблон является Юникод строкой.
Количество групп захвата в шаблоне.
Словарь, отображающий любые символьные имена групп, определенные (?P<id>) , на номера групп. Словарь пуст, если в шаблоне не использовались символические группы.
Строка шаблона, из которой был скомпилирован объект шаблона.
Изменено в версии 3.7: Добавлена поддержка copy.copy() и copy.deepcopy() . Скомпилированные объекты регулярных выражений считаются атомарными.
Match объекты¶
Match объекты всегда рассматриваются в логическом контексте как True . Поскольку match() и search() возвращают None при отсутствии совпадения, вы можете проверить, было ли совпадение, с помощью простого оператора if :
Объекты Match поддерживают следующие методы и атрибуты:
Match. expand ( template ) ¶
Возвращает строку, полученную путём подстановки обратной косой черты в шаблоне строки template, также как это сделано методом sub() . Экранированные (например, \n ) преобразуются в соответствующие символы, а числовые обратные ссылки ( \1 , \2 ) и именованные обратные ссылки ( \g<1> , \g<name> ) заменяются содержимым соответствующей группы.
Изменено в версии 3.5: Несовпадающие группы заменяются пустой строкой.
Возвращает одну или несколько подгрупп совпадения. Если есть один аргумент, результатом будет одна строка; если есть несколько аргументов, результатом будет кортеж с одним элементом на аргумент. Без аргументов группа group1 по умолчанию равна нулю (возвращается все совпадение). Если аргумент groupN равен нулю, соответствующее возвращаемое значение является всей совпадающей строкой; если он находится в включающем диапазоне [1..99], это строка, соответствующая соответствующей группе в скобках. Если номер группы отрицательный или превышает количество групп, определенных в шаблоне, возникает исключение IndexError . Если группа содержится в части шаблона, который не соответствует, соответствующий результат будет None . Если группа содержится в части шаблона, совпадающей несколько раз, возвращается последнее совпадение.
Если в регулярном выражении используется синтаксис (?P<name>. ) , аргументы groupN также могут быть строками, идентифицирующими группы по их имени. Если строковый аргумент не используется в качестве имени группы в шаблоне, возникает исключение IndexError .
В меру сложный пример:
Именованные группы также могут упоминаться по их индексу:
Если группа соответствует несколько раз, доступно только последнее совпадение:
Идентична m.group(g) . Упрощает доступ к отдельной группе из совпадения:
Добавлено в версии 3.6.
Возвращает кортеж, содержащий все подгруппы совпадения, от 1 до количества групп в шаблоне. Аргумент default используется для групп, которые не участвовали в совпадении; по умолчанию это None .
Если мы сделаем десятичный знак и все после него необязательными, не все группы смогут участвовать в совпадении. Группы по умолчанию будут None , если не указан аргумент default:
Возвращает словарь, содержащий все именуемые подгруппы совпадения, с ключом по имени подгруппы. Аргумент default используется для групп, которые не участвовали в совпадении; по умолчанию это None . Например:
Возвращает индексы начала и конца подстроки, соответствующей group; group по умолчанию равна нулю (то есть вся совпадающая подстрока). Возвращает -1 , если group существует, но не участвовала в совпадении. Для объекта сопоставления m и группы g, которая внесла вклад в сопоставление, подстрока, сопоставленная группой g (эквивалент m.group(g) ), равна:
Обратите внимание, что m.start(group) будет равно m.end(group) , если group соответствует пустой строке. Например, после m = re.search(‘b(c?)’, ‘cba’) m.start(0) равен 1, m.end(0) равен 2, m.start(1) и m.end(1) равны 2, а m.start(2) вызывает исключение IndexError .
Пример, который удалит remove_this из адресов электронной почты:
Для соответствия m возвращает 2-кортеж (m.start(group), m.end(group)) . Обратите внимание: если group не участвовала в совпадении, это (-1, -1) . group по умолчанию равна нулю, полное совпадение.
Значение pos, переданное методу search() или match() из объекта регулярного выражения . Это индекс в строке, с которой механизм RE начал поиск совпадения.
Значение endpos, переданное методу search() или match() из объекта регулярного выражения . Это индекс в строке, за который движок RE не пойдет.
Целочисленный индекс последней совпавшей группы захвата или None , если ни одна группа не была сопоставлена вообще. Например, выражения (a)b , ((a)(b)) и ((ab)) будут иметь lastindex == 1 , если их применить к строке ‘ab’ , а выражение (a)(b) будет иметь lastindex == 2 , если применить к той же строке.
Имя последней совпавшей группы захвата или None , если у группы не было имени или если группа вообще не была сопоставлена.
Объект регулярного выражения , чей метод match() или search() создал этот экземпляр соответствия.
Строка передается в match() или search() .
Изменено в версии 3.7: Добавлена поддержка copy.copy() и copy.deepcopy() . Объекты соответствия считаются атомарными.
Примеры регулярных выражений¶
Проверка на пару¶
В этом примере мы будем использовать следующую вспомогательную функцию для более изящного отображения совпадающих объектов:
Предположим, вы пишете покерную программу, в которой рука игрока представлена в виде строки из 5 символов, где каждый символ представляет карту: «a» — туз, «k» — король, «q» — дама, «j» — валет, «t» означает 10, а от «2» до «9» — карту с этим значением.
Чтобы узнать, является ли данная строка допустимой рукой, можно сделать следующее:
Последняя рука, «727ak» , содержала пару или две карты одного достоинства. Чтобы сопоставить это с регулярным выражением, можно использовать обратные ссылки как таковые:
Чтобы узнать, из какой карты состоит пара, можно использовать метод group() объекта match следующим образом:
Имитация scanf()¶
У Python в настоящее время нет эквивалента scanf() . Регулярные выражения обычно более эффективны, хотя и более подробны, чем форматные строки scanf() . В таблице ниже представлены некоторые более или менее эквивалентные сопоставления между токенами формата scanf() и регулярными выражениями.
| scanf() токен | Регулярное выражение |
|---|---|
| %c | . |
| %5c | . |
| %d | [-+]?\d+ |
| %e , %E , %f , %g | [-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)? |
| %i | [-+]?(0[xX][\dA-Fa-f]+|0[0-7]*|\d+) |
| %o | [-+]?[0-7]+ |
| %s | \S+ |
| %u | \d+ |
| %x , %X | [-+]?(0[xX])?[\dA-Fa-f]+ |
Чтобы извлечь имя файла и числа из строки вроде:
вы должны использовать формат scanf() , например:
Эквивалентное регулярное выражение было бы:
search() против match()¶
Python предлагает две разные примитивные операции, основанные на регулярных выражениях: re.match() проверяет совпадение только в начале строки, а re.search() проверяет совпадение в любом месте строки (это то, что Perl делает по умолчанию).
Регулярные выражения, начинающиеся с ‘^’ , можно использовать с search() , чтобы ограничить совпадение в начале строки:
Однако обратите внимание, что в режиме MULTILINE match() соответствует только началу строки, тогда как использование search() с регулярным выражением, начинающимся с ‘^’ , будет соответствовать началу каждой строки.
Создание телефонной книги¶
split() разбивает строку на список, ограниченный переданным шаблоном. Этот метод неоценим для преобразования текстовых данных в структуры данных, которые могут быть легко прочитаны и изменены Python, как показано в следующем примере создания телефонной книги.
Во-первых, нужны данные для работы. Обычно данные могут быть из файла, здесь же мы используем строковый синтаксис в тройных кавычках
Записи разделяются одной или несколькими символами новой строки. Теперь преобразуем строку в список, в котором каждая непустая строка содержит свою запись:
Наконец, разделим каждую запись на список с именем, фамилией, номером телефона и адресом. Мы используем параметр maxsplit в split() , потому что в адресе есть пробелы. Наш шаблон разделения:
Шаблон 😕 соответствует двоеточию после фамилии, поэтому он не встречается в списке результатов. С maxsplit или 4 мы могли отделить номер дома от названия улицы:
Выравнивание текста¶
sub() заменяет каждое вхождение шаблона строкой или результатом функции. В этом примере демонстрируется использование sub() с функцией изменения текста или рандомизации всех символов в каждом слове предложения, кроме первого и последнего символов:
Поиск всех наречий¶
findall() соответствует всем вхождениям шаблона, а не только первому, как search() . Например, если писатель хотел найти все наречия в каком-то тексте, он мог бы использовать findall() следующим образом:
Поиск всех наречий и их положений¶
Если кто-то хочет получить больше информации обо всех совпадениях шаблона, чем соответствующий текст, полезен finditer() , поскольку он предоставляет объекты сопоставления вместо строк. Продолжая предыдущий пример, если писатель хотел найти все наречия и их позиции в каком-либо тексте, он использовал бы finditer() следующим образом:
Обозначение необработанных строк¶
Нотация необработанных строк ( r»text» ) сохраняет читаемость регулярного выражения. Без неё каждая обратная косая черта ( ‘\’ ) в регулярном выражении должна быть снабжена экранирующим префиксом. Например, две следующие строки кода функционально идентичны:
Если кто-то хочет сопоставить буквальную обратную косую черту, её нужно экранировать в регулярном выражении. В случае необработанной строковой записи это означает r»\\» . Без нотации необработанных строк необходимо использовать «\\\\» , что делает следующие строки кода функционально идентичными:
Написание токенизатора¶
Токенизатор или сканер анализирует строку для классификации групп символов. Это ценный первый шаг при написании компилятора или интерпретатора.
Категории текста указываются с помощью регулярных выражений. Методика состоит в том, чтобы объединить их в одно основное регулярное выражение и перебрать последовательные совпадения:
Python RegEx: практическое применение регулярок
Рассмотрим регулярные выражения в Python, начиная синтаксисом и заканчивая примерами использования.
Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.
Основы регулярных выражений
Регулярками в Python называются шаблоны, которые используются для поиска соответствующего фрагмента текста и сопоставления символов.
Грубо говоря, у нас есть input-поле, в которое должен вводиться email-адрес. Но пока мы не зададим проверку валидности введённого email-адреса, в этой строке может оказаться совершенно любой набор символов, а нам это не нужно.
Чтобы выявить ошибку при вводе некорректного адреса электронной почты, можно использовать следующее регулярное выражение:
По сути, наш шаблон — это набор символов, который проверяет строку на соответствие заданному правилу. Давайте разберёмся, как это работает.
Синтаксис RegEx
Синтаксис у регулярок необычный. Символы могут быть как буквами или цифрами, так и метасимволами, которые задают шаблон строки:
Также есть дополнительные конструкции, которые позволяют сокращать регулярные выражения:
- \d — соответствует любой одной цифре и заменяет собой выражение [0-9];
- \D — исключает все цифры и заменяет [^0-9];
- \w — заменяет любую цифру, букву, а также знак нижнего подчёркивания;
- \W — любой символ кроме латиницы, цифр или нижнего подчёркивания;
- \s — соответствует любому пробельному символу;
- \S — описывает любой непробельный символ.
Для чего используются регулярные выражения
- для определения нужного формата, например телефонного номера или email-адреса;
- для разбивки строк на подстроки;
- для поиска, замены и извлечения символов;
- для быстрого выполнения нетривиальных операций.
Синтаксис таких выражений в основном стандартизирован, так что вам следует понять их лишь раз, чтобы использовать в любом языке программирования.
Примечание Не стоит забывать, что регулярные выражения не всегда оптимальны, и для простых операций часто достаточно встроенных в Python функций.
Хотите узнать больше? Обратите внимание на статью о регулярках для новичков.
Регулярные выражения в Python
В Python для работы с регулярками есть модуль re . Его нужно просто импортировать:
А вот наиболее популярные методы, которые предоставляет модуль:
- re.match()
- re.search()
- re.findall()
- re.split()
- re.sub()
- re.compile()
Рассмотрим каждый из них подробнее.
re.match(pattern, string)
Этот метод ищет по заданному шаблону в начале строки. Например, если мы вызовем метод match() на строке «AV Analytics AV» с шаблоном «AV», то он завершится успешно. Но если мы будем искать «Analytics», то результат будет отрицательный:
Искомая подстрока найдена. Чтобы вывести её содержимое, применим метод group() (мы используем «r» перед строкой шаблона, чтобы показать, что это «сырая» строка в Python):
Теперь попробуем найти «Analytics» в данной строке. Поскольку строка начинается на «AV», метод вернет None :
Также есть методы start() и end() для того, чтобы узнать начальную и конечную позицию найденной строки.
Эти методы иногда очень полезны для работы со строками.
re.search(pattern, string)
Метод похож на match() , но ищет не только в начале строки. В отличие от предыдущего, search() вернёт объект, если мы попытаемся найти «Analytics»:
Метод search() ищет по всей строке, но возвращает только первое найденное совпадение.
re.findall(pattern, string)
Возвращает список всех найденных совпадений. У метода findall() нет ограничений на поиск в начале или конце строки. Если мы будем искать «AV» в нашей строке, он вернет все вхождения «AV». Для поиска рекомендуется использовать именно findall() , так как он может работать и как re.search() , и как re.match() .
re.split(pattern, string, [maxsplit=0])
Этот метод разделяет строку по заданному шаблону.
В примере мы разделили слово «Analytics» по букве «y». Метод split() принимает также аргумент maxsplit со значением по умолчанию, равным 0. В данном случае он разделит строку столько раз, сколько возможно, но если указать этот аргумент, то разделение будет произведено не более указанного количества раз. Давайте посмотрим на примеры Python RegEx:
Мы установили параметр maxsplit равным 1, и в результате строка была разделена на две части вместо трех.
re.sub(pattern, repl, string)
Ищет шаблон в строке и заменяет его на указанную подстроку. Если шаблон не найден, строка остается неизменной.
re.compile(pattern, repl, string)
Мы можем собрать регулярное выражение в отдельный объект, который может быть использован для поиска. Это также избавляет от переписывания одного и того же выражения.
До сих пор мы рассматривали поиск определенной последовательности символов. Но что, если у нас нет определенного шаблона, и нам надо вернуть набор символов из строки, отвечающий определенным правилам? Такая задача часто стоит при извлечении информации из строк. Это можно сделать, написав выражение с использованием специальных символов. Вот наиболее часто используемые из них:
| Оператор | Описание |
|---|---|
| . | Один любой символ, кроме новой строки \n. |
| ? | 0 или 1 вхождение шаблона слева |
| + | 1 и более вхождений шаблона слева |
| * | 0 и более вхождений шаблона слева |
| \w | Любая цифра или буква (\W — все, кроме буквы или цифры) |
| \d | Любая цифра [0-9] (\D — все, кроме цифры) |
| \s | Любой пробельный символ (\S — любой непробельный символ) |
| \b | Граница слова |
| [..] | Один из символов в скобках ([^..] — любой символ, кроме тех, что в скобках) |
| \ | Экранирование специальных символов (\. означает точку или \+ — знак «плюс») |
| ^ и $ | Начало и конец строки соответственно |
| От n до m вхождений ( — от 0 до m) | |
| a|b | Соответствует a или b |
| () | Группирует выражение и возвращает найденный текст |
| \t, \n, \r | Символ табуляции, новой строки и возврата каретки соответственно |
Больше информации по специальным символам можно найти в документации для регулярных выражений в Python 3.
Перейдём к практическому применению Python регулярных выражений и рассмотрим примеры.
Задачи
Вернуть первое слово из строки
Сначала попробуем вытащить каждый символ (используя . )
Для того, чтобы в конечный результат не попал пробел, используем вместо . \w .
Теперь попробуем достать каждое слово (используя * или + )
И снова в результат попали пробелы, так как * означает «ноль или более символов». Для того, чтобы их убрать, используем + :
Теперь вытащим первое слово, используя ^ :
Если мы используем $ вместо ^ , то мы получим последнее слово, а не первое:
Вернуть первые два символа каждого слова
Вариант 1: используя \w , вытащить два последовательных символа, кроме пробельных, из каждого слова:
Вариант 2: вытащить два последовательных символа, используя символ границы слова ( \b ):
Вернуть домены из списка email-адресов
Сначала вернём все символы после «@»:
Как видим, части «.com», «.in» и т. д. не попали в результат. Изменим наш код:
Второй вариант — вытащить только домен верхнего уровня, используя группировку — ( ) :
Извлечь дату из строки
Используем \d для извлечения цифр.
Для извлечения только года нам опять помогут скобки:
Извлечь слова, начинающиеся на гласную
Для начала вернем все слова:
А теперь — только те, которые начинаются на определенные буквы (используя [] ):
Выше мы видим обрезанные слова «argest» и «ommunity». Для того, чтобы убрать их, используем \b для обозначения границы слова:
Также мы можем использовать ^ внутри квадратных скобок для инвертирования группы:
В результат попали слова, «начинающиеся» с пробела. Уберем их, включив пробел в диапазон в квадратных скобках:
Проверить формат телефонного номера
Номер должен быть длиной 10 знаков и начинаться с 8 или 9. Есть список телефонных номеров, и нужно проверить их, используя регулярки в Python:
Разбить строку по нескольким разделителям
Также мы можем использовать метод re.sub() для замены всех разделителей пробелами:
Извлечь информацию из html-файла
Допустим, нужно извлечь информацию из html-файла, заключенную между <td> и </td> , кроме первого столбца с номером. Также будем считать, что html-код содержится в строке.
Пример содержимого html-файла:
С помощью регулярных выражений в Python это можно решить так (если поместить содержимое файла в переменную test_str ):