The module defines several functions, constants, and an exception. Some of the functions are simplified versions of the full-featured methods for compiled regular expressions. Most non-trivial applications always use the compiled form.<\/p>\n\n\n\n
re.compile<\/code>(pattern<\/em>,\u00a0flags=0<\/em>)<\/h3>\n\n\n\nCompile a regular expression pattern into a regular expression object, which can be used for matching using its match()<\/code><\/a> and search()<\/code><\/a> methods, described below.<\/p>\n\n\n\nThe expression\u2019s behavior can be modified by specifying a\u00a0flags<\/em>\u00a0value. Values can be any of the following variables, combined using bitwise OR (the\u00a0|<\/code>\u00a0operator).<\/p>\n\n\n\nThe sequence<\/p>\n\n\n\n
prog = re.compile(pattern)\nresult = prog.match(string)\n<\/pre>\n\n\n\nis equivalent to<\/p>\n\n\n\n
result = re.match(pattern, string)\n<\/pre>\n\n\n\nbut using re.compile()<\/code><\/a> and saving the resulting regular expression object for reuse is more efficient when the expression will be used several times in a single program.<\/p>\n\n\n\nNote<\/p>\n\n\n\n
The compiled versions of the most recent patterns passed to re.match()<\/code><\/a>, re.search()<\/code><\/a> or re.compile()<\/code><\/a> are cached, so programs that use only a few regular expressions at a time needn\u2019t worry about compiling regular expressions.re.<\/code>DEBUG<\/code><\/p>\n\n\n\nDisplay debug information about compiled expression.re.<\/code>I<\/code>re.<\/code>IGNORECASE<\/code><\/p>\n\n\n\nPerform case-insensitive matching; expressions like [A-Z]<\/code> will match lowercase letters, too. This is not affected by the current locale. To get this effect on non-ASCII Unicode characters such as \u00fc<\/code> and \u00dc<\/code>, add the UNICODE<\/code><\/a> flag.re.<\/code>L<\/code>re.<\/code>LOCALE<\/code><\/p>\n\n\n\nMake \\w<\/code>, \\W<\/code>, \\b<\/code>, \\B<\/code>, \\s<\/code> and \\S<\/code> dependent on the current locale.re.<\/code>M<\/code>re.<\/code>MULTILINE<\/code><\/p>\n\n\n\nWhen specified, the pattern character '^'<\/code> matches at the beginning of the string and at the beginning of each line (immediately following each newline); and the pattern character '$'<\/code> matches at the end of the string and at the end of each line (immediately preceding each newline). By default, '^'<\/code> matches only at the beginning of the string, and '$'<\/code> only at the end of the string and immediately before the newline (if any) at the end of the string.re.<\/code>S<\/code>re.<\/code>DOTALL<\/code><\/p>\n\n\n\nMake the '.'<\/code> special character match any character at all, including a newline; without this flag, '.'<\/code> will match anything except<\/em> a newline.re.<\/code>U<\/code>re.<\/code>UNICODE<\/code><\/p>\n\n\n\nMake the \\w<\/code>, \\W<\/code>, \\b<\/code>, \\B<\/code>, \\d<\/code>, \\D<\/code>, \\s<\/code> and \\S<\/code> sequences dependent on the Unicode character properties database. Also enables non-ASCII matching for IGNORECASE<\/code><\/a>.<\/p>\n\n\n\nNew in version 2.0.<\/em>re.<\/code>X<\/code>re.<\/code>VERBOSE<\/code><\/p>\n\n\n\nThis flag allows you to write regular expressions that look nicer and are more readable by allowing you to visually separate logical sections of the pattern and add comments. Whitespace within the pattern is ignored, except when in a character class, or when preceded by an unescaped backslash, or within tokens like *?<\/code>, (?:<\/code> or (?P<...><\/code>. When a line contains a #<\/code> that is not in a character class and is not preceded by an unescaped backslash, all characters from the leftmost such #<\/code> through the end of the line are ignored.<\/p>\n\n\n\nThis means that the two following regular expression objects that match a decimal number are functionally equal:<\/p>\n\n\n\n
a = re.compile(r\"\"\"\\d + # the integral part\n \\. # the decimal point\n \\d * # some fractional digits\"\"\", re.X)\nb = re.compile(r\"\\d+\\.\\d*\")\n<\/pre>\n\n\n\nre.<\/code>search<\/code>(pattern<\/em>, string<\/em>, flags=0<\/em>)<\/h3>\n\n\n\nScan through\u00a0string<\/em>\u00a0looking for the first location where the regular expression\u00a0pattern<\/em>\u00a0produces a match, and return a corresponding\u00a0MatchObject<\/code><\/a>\u00a0instance. Return\u00a0None<\/code>\u00a0if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.<\/p>\n\n\n\nre.match<\/code>(pattern<\/em>,\u00a0string<\/em>,\u00a0flags=0<\/em>)<\/h3>\n\n\n\nIf zero or more characters at the beginning of string<\/em> match the regular expression pattern<\/em>, return a corresponding MatchObject<\/code><\/a> instance. Return None<\/code> if the string does not match the pattern; note that this is different from a zero-length match.<\/p>\n\n\n\nNote that even in MULTILINE<\/code><\/a> mode, re.match()<\/code><\/a> will only match at the beginning of the string and not at the beginning of each line.<\/p>\n\n\n\nIf you want to locate a match anywhere in\u00a0string<\/em>, use\u00a0search()<\/code><\/a>\u00a0instead (see also\u00a0search() vs. match()<\/a>).<\/p>\n\n\n\nre.split<\/code>(pattern<\/em>,\u00a0string<\/em>,\u00a0maxsplit=0<\/em>,\u00a0flags=0<\/em>)<\/h3>\n\n\n\nSplit string<\/em> by the occurrences of pattern<\/em>. If capturing parentheses are used in pattern<\/em>, then the text of all groups in the pattern are also returned as part of the resulting list. If maxsplit<\/em> is nonzero, at most maxsplit<\/em> splits occur, and the remainder of the string is returned as the final element of the list. (Incompatibility note: in the original Python 1.5 release, maxsplit<\/em> was ignored. This has been fixed in later releases.)<\/p>\n\n\n\n>>> <\/strong>re.split('\\W+', 'Words, words, words.')\n['Words', 'words', 'words', '']\n>>> <\/strong>re.split('(\\W+)', 'Words, words, words.')\n['Words', ', ', 'words', ', ', 'words', '.', '']\n>>> <\/strong>re.split('\\W+', 'Words, words, words.', 1)\n['Words', 'words, words.']\n>>> <\/strong>re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)\n['0', '3', '9']\n<\/pre>\n\n\n\nIf there are capturing groups in the separator and it matches at the start of the string, the result will start with an empty string. The same holds for the end of the string:<\/p>\n\n\n\n
>>> <\/strong>re.split('(\\W+)', '...words, words...')\n['', '...', 'words', ', ', 'words', '...', '']\n<\/pre>\n\n\n\nThat way, separator components are always found at the same relative indices within the result list (e.g., if there\u2019s one capturing group in the separator, the 0th, the 2nd and so forth).<\/p>\n\n\n\n
Note that split<\/em> will never split a string on an empty pattern match. For example:<\/p>\n\n\n\n>>> <\/strong>re.split('x*', 'foo')\n['foo']\n>>> <\/strong>re.split(\"(?m)^$\", \"foo\\n\\n<\/strong>bar\\n<\/strong>\")\n['foo\\n\\nbar\\n']\n<\/pre>\n\n\n\nChanged in version 2.7:\u00a0<\/em>Added the optional flags argument.<\/p>\n\n\n\nre.findall<\/code>(pattern<\/em>,\u00a0string<\/em>,\u00a0flags=0<\/em>)<\/h3>\n\n\n\nReturn all non-overlapping matches of pattern<\/em> in string<\/em>, as a list of strings. The string<\/em> is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result.<\/p>\n\n\n\nNote<\/p>\n\n\n\n
Due to the limitation of the current implementation the character following an empty match is not included in a next match, so findall(r'^|\\w+', 'two words')<\/code> returns ['', 'wo', 'words']<\/code> (note missed \u201ct\u201d). This is changed in Python 3.7.<\/p>\n\n\n\nNew in version 1.5.2.<\/em><\/p>\n\n\n\nChanged in version 2.4:\u00a0<\/em>Added the optional flags argument.<\/p>\n\n\n\nre.finditer<\/code>(pattern<\/em>,\u00a0string<\/em>,\u00a0flags=0<\/em>)<\/h3>\n\n\n\nReturn an iterator<\/a> yielding MatchObject<\/code><\/a> instances over all non-overlapping matches for the RE pattern<\/em> in string<\/em>. The string<\/em> is scanned left-to-right, and matches are returned in the order found. Empty matches are included in the result. See also the note about findall()<\/code><\/a>.<\/p>\n\n\n\nNew in version 2.2.<\/em><\/p>\n\n\n\nChanged in version 2.4: <\/em>Added the optional flags argument.re.<\/code>sub<\/code>(pattern<\/em>, repl<\/em>, string<\/em>, count=0<\/em>, flags=0<\/em>)<\/p>\n\n\n\nReturn the string obtained by replacing the leftmost non-overlapping occurrences of pattern<\/em> in string<\/em> by the replacement repl<\/em>. If the pattern isn\u2019t found, string<\/em> is returned unchanged. repl<\/em> can be a string or a function; if it is a string, any backslash escapes in it are processed. That is, \\n<\/code> is converted to a single newline character, \\r<\/code> is converted to a carriage return, and so forth. Unknown escapes such as \\j<\/code> are left alone. Backreferences, such as \\6<\/code>, are replaced with the substring matched by group 6 in the pattern. For example:<\/p>\n\n\n\n>>> <\/strong>re.sub(r'def\\s+([a-zA-Z_][a-zA-Z_0-9]*)\\s*\\(\\s*\\):',\n... <\/strong> r'static PyObject*\\npy_\\1(void)\\n{',\n... <\/strong> 'def myfunc():')\n'static PyObject*\\npy_myfunc(void)\\n{'\n<\/pre>\n\n\n\nIf repl<\/em> is a function, it is called for every non-overlapping occurrence of pattern<\/em>. The function takes a single match object argument, and returns the replacement string. For example:<\/p>\n\n\n\n>>> <\/strong>def<\/strong> dashrepl(matchobj):\n... <\/strong> if<\/strong> matchobj.group(0) == '-': return<\/strong> ' '\n... <\/strong> else<\/strong>: return<\/strong> '-'\n>>> <\/strong>re.sub('-{1,2}', dashrepl, 'pro----gram-files')\n'pro--gram files'\n>>> <\/strong>re.sub(r'\\sAND\\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)\n'Baked Beans & Spam'\n<\/pre>\n\n\n\nThe pattern may be a string or an RE object.<\/p>\n\n\n\n
The optional argument count<\/em> is the maximum number of pattern occurrences to be replaced; count<\/em> must be a non-negative integer. If omitted or zero, all occurrences will be replaced. Empty matches for the pattern are replaced only when not adjacent to a previous match, so sub('x*', '-', 'abc')<\/code> returns '-a-b-c-'<\/code>.<\/p>\n\n\n\nIn string-type repl<\/em> arguments, in addition to the character escapes and backreferences described above, \\g<name><\/code> will use the substring matched by the group named name<\/code>, as defined by the (?P<name>...)<\/code> syntax. \\g<number><\/code> uses the corresponding group number; \\g<2><\/code> is therefore equivalent to \\2<\/code>, but isn\u2019t ambiguous in a replacement such as \\g<2>0<\/code>. \\20<\/code> would be interpreted as a reference to group 20, not a reference to group 2 followed by the literal character '0'<\/code>. The backreference \\g<0><\/code> substitutes in the entire substring matched by the RE.<\/p>\n\n\n\nChanged in version 2.7: <\/em>Added the optional flags argument.re.<\/code>subn<\/code>(pattern<\/em>, repl<\/em>, string<\/em>, count=0<\/em>, flags=0<\/em>)<\/p>\n\n\n\nPerform the same operation as sub()<\/code><\/a>, but return a tuple (new_string, number_of_subs_made)<\/code>.<\/p>\n\n\n\n