Regular Expression Syntax¶

A regular expression (or RE) specifies a set of strings that matches it; thefunctions in this module let you check if a particular string matches a givenregular expression (or if a given regular expression matches a particularstring, which comes down to the same thing).

Regular expressions can be concatenated to form new regular expressions; ifAandB are both regular expressions, thenAB is also a regular expression.In general, if a stringp matchesA and another stringq matchesB, thestringpq will match AB. This holds unlessA orB contain low precedenceoperations; boundary conditions betweenA andB; or have numbered groupreferences. Thus, complex expressions can easily be constructed from simplerprimitive expressions like the ones described here. For details of the theoryand 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 furtherinformation and a gentler presentation, consult theRegular Expression HOWTO.

Regular expressions can contain both special and ordinary characters. Mostordinary characters, like'A','a', or'0', are the simplest regularexpressions; they simply match themselves. You can concatenate ordinarycharacters, solast matches the string'last'. (In the rest of thissection, we’ll write RE’s inthisspecialstyle, usually without quotes, andstrings to be matched'insinglequotes'.)

Some characters, like'|' or'(', are special. Specialcharacters either stand for classes of ordinary characters, or affecthow the regular expressions around them are interpreted.

Repetition operators or quantifiers (*,+,?,{m,n}, etc) cannot bedirectly nested. This avoids ambiguity with the non-greedy modifier suffix?, and with other modifiers in other implementations. To apply a secondrepetition to an inner repetition, parentheses may be used. For example,the expression(?:a{6})* matches any multiple of six'a' characters.

The special characters are:

.

(Dot.) In the default mode, this matches any character except a newline. IftheDOTALL flag has been specified, this matches any characterincluding a newline.(?s:.) matches any character regardless of flags.

^

(Caret.) Matches the start of the string, and inMULTILINE mode alsomatches immediately after each newline.

$

Matches the end of the string or just before the newline at the end of thestring, and inMULTILINE mode also matches before a newline.foomatches both ‘foo’ and ‘foobar’, while the regular expressionfoo$ matchesonly ‘foo’. More interestingly, searching forfoo.$ in'foo1\nfoo2\n'matches ‘foo2’ normally, but ‘foo1’ inMULTILINE mode; searching fora single$ in'foo\n' will find two (empty) matches: one just beforethe newline, and one at the end of the string.

*

Causes the resulting RE to match 0 or more repetitions of the preceding RE, asmany repetitions as are possible.ab* will match ‘a’, ‘ab’, or ‘a’ followedby 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 notmatch 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 allgreedy; they matchas much text as possible. Sometimes this behaviour isn’t desired; if the RE<.*> is matched against'<a>b<c>', it will match the entirestring, and not just'<a>'. Adding? after the quantifier makes itperform the match innon-greedy orminimal fashion; asfewcharacters as possible will be matched. Using the RE<.*?> will matchonly'<a>'.

*+,++,?+

Like the'*','+', and'?' quantifiers, those where'+' isappended also match as many times as possible.However, unlike the true greedy quantifiers, these do not allowback-tracking when the expression following it fails to match.These are known aspossessive quantifiers.For example,a*a will match'aaaa' because thea* will matchall 4'a's, but, when the final'a' is encountered, theexpression is backtracked so that in the end thea* ends up matching3'a's total, and the fourth'a' is matched by the final'a'.However, whena*+a is used to match'aaaa', thea*+ willmatch all 4'a', but when the final'a' fails to find any morecharacters to match, the expression cannot be backtracked and will thusfail to match.x*+,x++ andx?+ are equivalent to(?>x*),(?>x+)and(?>x?) correspondingly.

Added in version 3.11.

{m}

Specifies that exactlym copies of the previous RE should be matched; fewermatches cause the entire RE not to match. For example,a{6} will matchexactly six'a' characters, but not five.

{m,n}

Causes the resulting RE to match fromm ton repetitions of the precedingRE, attempting to match as many repetitions as possible. For example,a{3,5} will match from 3 to 5'a' characters. Omittingm specifies alower bound of zero, and omittingn specifies an infinite upper bound. As anexample,a{4,}b will match'aaaab' or a thousand'a' charactersfollowed by a'b', but not'aaab'. The comma may not be omitted or themodifier would be confused with the previously described form.

{m,n}?

Causes the resulting RE to match fromm ton repetitions of the precedingRE, attempting to match asfew repetitions as possible. This is thenon-greedy version of the previous quantifier. For example, on the6-character string'aaaaaa',a{3,5} will match 5'a' characters,whilea{3,5}? will only match 3 characters.

{m,n}+

Causes the resulting RE to match fromm ton repetitions of thepreceding RE, attempting to match as many repetitions as possiblewithout establishing any backtracking points.This is the possessive version of the quantifier above.For example, on the 6-character string'aaaaaa',a{3,5}+aaattempt to match 5'a' characters, then, requiring 2 more'a's,will need more characters than available and thus fail, whilea{3,5}aa will match witha{3,5} capturing 5, then 4'a'sby backtracking and then the final 2'a's are matched by the finalaa in the pattern.x{m,n}+ is equivalent to(?>x{m,n}).

Added in version 3.11.

\

Either escapes special characters (permitting you to match characters like'*','?', and so forth), or signals a special sequence; specialsequences are discussed below.

If you’re not using a raw string to express the pattern, remember that Pythonalso uses the backslash as an escape sequence in string literals; if the escapesequence isn’t recognized by Python’s parser, the backslash and subsequentcharacter are included in the resulting string. However, if Python wouldrecognize the resulting sequence, the backslash should be repeated twice. Thisis complicated and hard to understand, so it’s highly recommended that you useraw 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 separatingthem by a'-', for example[a-z] will match any lowercase ASCII letter,[0-5][0-9] will match all the two-digits numbers from00 to59, 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 except backslash lose their special meaning inside sets.For example,[(+*)] will match any of the literal characters'(','+','*', or')'.

• Backslash either escapes characters which have special meaning in a setsuch as'-',']','^' and'\\' itself or signalsa special sequence which represents a single character such as\xa0 or\n or a character class such as\w or\S(defined below).Note that\b represents a single “backspace” character,not a word boundary as outside a set, and numeric escapessuch as\1 are always octal escapes, not group references.Special sequences which do not match a single character such as\Aand\Z are not allowed.

• Characters that are not within a range can be matched bycomplementingthe set. If the first character of the set is'^', all the charactersthat arenot in the set will be matched. For example,[^5] will matchany character except'5', and[^^] will match any character except'^'.^ has no special meaning if it’s not the first character inthe set.

• To match a literal']' inside a set, precede it with a backslash, orplace 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 inUnicode TechnicalStandard #18 might be added in the future. This would change thesyntax, so to facilitate this change aFutureWarning will be raisedin ambiguous cases for the time being.That includes sets starting with a literal'[' or containing literalcharacter sequences'--','&&','~~', and'||'. Toavoid a warning escape them with a backslash.

Changed in version 3.7:FutureWarning is raised if a character set contains constructsthat will change semantically in the future.

|

A|B, whereA andB can be arbitrary REs, creates a regular expression thatwill match eitherA orB. An arbitrary number of REs can be separated by the'|' in this way. This can be used inside groups (see below) as well. Asthe target string is scanned, REs separated by'|' are tried from left toright. When one pattern completely matches, that branch is accepted. This meansthat onceA matches,B will not be tested further, even if it wouldproduce a longer overall match. In other words, the'|' operator is nevergreedy. To match a literal'|', use\|, or enclose it inside acharacter class, as in[|].

(...)

Matches whatever regular expression is inside the parentheses, and indicates thestart and end of a group; the contents of a group can be retrieved after a matchhas been performed, and can be matched later in the string with the\numberspecial 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 meaningfulotherwise). The first character after the'?' determines what the meaningand further syntax of the construct is. Extensions usually do not create a newgroup;(?P<name>...) is the only exception to this rule. Following are thecurrently supported extensions.

(?aiLmsux)

(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 for the entire regular expression:

• 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)

• re.X (verbose)

(The flags are described inModule Contents.)This is useful if you wish to include the flags as part of theregular expression, instead of passing aflag argument to there.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 regularexpression is inside the parentheses, but the substring matched by the groupcannot be retrieved after performing a match or referenced later in thepattern.

(?aiLmsux-imsx:...)

(Zero or more letters from the set'a','i','L','m','s','u','x',optionally followed by'-' followed byone or more letters from the'i','m','s','x'.)The letters set or remove the corresponding flags for the part of the expression:

• 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)

• re.X (verbose)

(The flags are described inModule Contents.)

The letters'a','L' and'u' are mutually exclusive when usedas inline flags, so they can’t be combined or follow'-'. Instead,when one of them appears in an inline group, it overrides the matching modein the enclosing group. In Unicode patterns(?a:...) switches toASCII-only matching, and(?u:...) switches to Unicode matching(default). In bytes patterns(?L:...) switches to locale dependentmatching, and(?a:...) switches to ASCII-only matching (default).This override is only in effect for the narrow inline group, and theoriginal matching mode is restored outside of the group.

Added 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, andif successful, continues to match the rest of the pattern following it.If the subsequent pattern fails to match, the stack can only be unwoundto a pointbefore the(?>...) because once exited, the expression,known as anatomic group, has thrown away all stack points withinitself.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 isno stack point before it, the entire expression would thus fail to match.

Added in version 3.11.

(?P<name>...)

Similar to regular parentheses, but the substring matched by the group isaccessible via the symbolic group namename. Group names must be validPython identifiers, and inbytes patterns they can only containbytes in the ASCII range. Each group name must be defined only once withina regular expression. A symbolic group is also a numbered group, just as ifthe group were not named.

Named groups can be referenced in three contexts. If the pattern is(?P<quote>['"]).*?(?P=quote) (i.e. matching a string quoted with eithersingle or double quotes):

Context of reference to group “quote”	Ways to reference it
in the same pattern itself	(?P=quote) (as shown) \1
when processing match objectm	m.group('quote') m.end('quote') (etc.)
in a string passed to thereplargument ofre.sub()	\g<quote> \g<1> \1

Changed in version 3.12:Inbytes patterns, groupname can only contain bytesin the ASCII range (b'\x00'-b'\x7f').

(?P=name)

A backreference to a named group; it matches whatever text was matched by theearlier group namedname.

(?#...)

A comment; the contents of the parentheses are simply ignored.

(?=...)

Matches if... matches next, but doesn’t consume any of the string. This iscalled alookahead assertion. For example,Isaac(?=Asimov) will match'Isaac' only if it’s followed by'Asimov'.

(?!...)

Matches if... doesn’t match next. This is anegative lookahead assertion.For example,Isaac(?!Asimov) will match'Isaac' only if it’snotfollowed by'Asimov'.

(?<=...)

Matches if the current position in the string is preceded by a match for...that ends at the current position. This is called apositive lookbehindassertion.(?<=abc)def will find a match in'abcdef', since thelookbehind will back up 3 characters and check if the contained pattern matches.The contained pattern must only match strings of some fixed length, meaning thatabc ora|b are allowed, buta* anda{3,4} are not. Note thatpatterns which start with positive lookbehind assertions will not match at thebeginning of the string being searched; you will most likely want to use thesearch() function rather than thematch() function:

>>>importre>>>m=re.search('(?<=abc)def','abcdef')>>>m.group(0)'def'

This example looks for a word following a hyphen:

>>>m=re.search(r'(?<=-)\w+','spam-egg')>>>m.group(0)'egg'

Changed in version 3.5:Added support for group references of fixed length.

(?<!...)

Matches if the current position in the string is not preceded by a match for.... This is called anegative lookbehind assertion. Similar topositive lookbehind assertions, the contained pattern must only match strings ofsome fixed length. Patterns which start with negative lookbehind assertions maymatch at the beginning of the string being searched.

(?(id/name)yes-pattern|no-pattern)

Will try to match withyes-pattern if the group with givenid orname exists, and withno-pattern if it doesn’t.no-pattern isoptional and can be omitted. For example,(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) is a poor email matching pattern, whichwill match with'<user@host.com>' as well as'user@host.com', butnot with'<user@host.com' nor'user@host.com>'.

Changed in version 3.12:Groupid can only contain ASCII digits.Inbytes patterns, groupname can only contain bytesin the ASCII range (b'\x00'-b'\x7f').

The special sequences consist of'\' and a character from the list below.If the ordinary character is not an ASCII digit or an ASCII letter, then theresulting RE will match the second character. For example,\$ matches thecharacter'$'.

\number

Matches the contents of the group of the same number. Groups are numberedstarting from 1. For example,(.+)\1 matches'thethe' or'5555',but not'thethe' (note the space after the group). This special sequencecan only be used to match one of the first 99 groups. If the first digit ofnumber is 0, ornumber is 3 octal digits long, it will not be interpreted asa group match, but as the character with octal valuenumber. Inside the'[' and']' of a character class, all numeric escapes are treated ascharacters.

\A

Matches only at the start of the string.

\b

Matches the empty string, but only at the beginning or end of a word.A word is defined as a sequence of word characters.Note that formally,\b is defined as the boundarybetween a\w and a\W character (or vice versa),or between\w and the beginning or end of the string.This means thatr'\bat\b' matches'at','at.','(at)',and'asatay' but not'attempt' or'atlas'.

The default word characters in Unicode (str) patternsare Unicode alphanumerics and the underscore,but this can be changed by using theASCII flag.Word boundaries are determined by the current localeif theLOCALE flag is used.

Note

Inside a character range,\b represents the backspace character,for compatibility with Python’s string literals.

\B

Matches the empty string,but only when it isnot at the beginning or end of a word.This means thatr'at\B' matches'athens','atom','attorney', but not'at','at.', or'at!'.\B is the opposite of\b,so word characters in Unicode (str) patternsare Unicode alphanumerics or the underscore,although this can be changed by using theASCII flag.Word boundaries are determined by the current localeif theLOCALE flag is used.

Note

Note that\B does not match an empty string, which differs fromRE implementations in other programming languages such as Perl.This behavior is kept for compatibility reasons.

\d

For Unicode (str) patterns:

Matches any Unicode decimal digit(that is, any character in Unicode character category[Nd]).This includes[0-9], and also many other digit characters.

Matches[0-9] if theASCII flag is used.

For 8-bit (bytes) patterns:

Matches any decimal digit in the ASCII character set;this is equivalent to[0-9].

\D

Matches any character which is not a decimal digit.This is the opposite of\d.

Matches[^0-9] if theASCII flag is used.

\s

For Unicode (str) patterns:

Matches Unicode whitespace characters (as defined bystr.isspace()).This includes[\t\n\r\f\v], and also many other characters, for example thenon-breaking spaces mandated by typography rules in many languages.

Matches[\t\n\r\f\v] if theASCII flag is used.

For 8-bit (bytes) patterns:

Matches characters considered whitespace in the ASCII character set;this is equivalent to[\t\n\r\f\v].

\S

Matches any character which is not a whitespace character. This isthe opposite of\s.

Matches[^\t\n\r\f\v] if theASCII flag is used.

\w

For Unicode (str) patterns:

Matches Unicode word characters;this includes all Unicode alphanumeric characters(as defined bystr.isalnum()),as well as the underscore (_).

Matches[a-zA-Z0-9_] if theASCII flag is used.

For 8-bit (bytes) patterns:

Matches characters considered alphanumeric in the ASCII character set;this is equivalent to[a-zA-Z0-9_].If theLOCALE flag is used,matches characters considered alphanumeric in the current locale and the underscore.

\W

Matches any character which is not a word character.This is the opposite of\w.By default, matches non-underscore (_) charactersfor whichstr.isalnum() returnsFalse.

Matches[^a-zA-Z0-9_] if theASCII flag is used.

If theLOCALE flag is used,matches characters which are neither alphanumeric in the current localenor the underscore.

\Z

Matches only at the end of the string.

Most of theescape sequences supported by Pythonstring literals are also accepted by the regular expression parser:

\a      \b      \f      \n\N      \r      \t      \u\U      \v      \x      \\

(Note that\b is used to represent word boundaries, and means “backspace”only inside character classes.)

'\u','\U', and'\N' escape sequences areonly recognized in Unicode (str) patterns.In bytes patterns they are errors.Unknown escapes of ASCII letters are reservedfor future use and treated as errors.

Octal escapes are included in a limited form. If the first digit is a 0, or ifthere are three octal digits, it is considered an octal escape. Otherwise, it isa group reference. As for string literals, octal escapes are always at mostthree digits in length.

Module Contents¶

The module defines several functions, constants, and an exception. Some of thefunctions are simplified versions of the full featured methods for compiledregular expressions. Most non-trivial applications always use the compiledform.

Regular Expression Objects¶

classre.Pattern¶

Compiled regular expression object returned byre.compile().

Changed in version 3.9:re.Pattern supports[] to indicate a Unicode (str) or bytes pattern.SeeGeneric Alias Type.

Pattern.search(string[,pos[,endpos]])¶

Scan throughstring looking for the first location where this regularexpression produces a match, and return a correspondingMatch.ReturnNone if no position in the string matches the pattern; note thatthis is different from finding a zero-length match at some point in the string.

The optional second parameterpos gives an index in the string where thesearch is to start; it defaults to0. This is not completely equivalent toslicing the string; the'^' pattern character matches at the real beginningof the string and at positions just after a newline, but not necessarily at theindex where the search is to start.

The optional parameterendpos limits how far the string will be searched; itwill be as if the string isendpos characters long, so only the charactersfrompos toendpos-1 will be searched for a match. Ifendpos is lessthanpos, no match will be found; otherwise, ifrx is a compiled regularexpression object,rx.search(string,0,50) is equivalent torx.search(string[:50],0).

>>>pattern=re.compile("d")>>>pattern.search("dog")# Match at index 0<re.Match object; span=(0, 1), match='d'>>>>pattern.search("dog",1)# No match; search doesn't include the "d"

Pattern.match(string[,pos[,endpos]])¶

If zero or more characters at thebeginning ofstring match this regularexpression, return a correspondingMatch. ReturnNone if thestring does not match the pattern; note that this is different from azero-length match.

The optionalpos andendpos parameters have the same meaning as for thesearch() method.

>>>pattern=re.compile("o")>>>pattern.match("dog")# No match as "o" is not at the start of "dog".>>>pattern.match("dog",1)# Match as "o" is the 2nd character of "dog".<re.Match object; span=(1, 2), match='o'>

If you want to locate a match anywhere instring, usesearch() instead (see alsosearch() vs. match()).

Pattern.fullmatch(string[,pos[,endpos]])¶

If the wholestring matches this regular expression, return a correspondingMatch. ReturnNone if the string does not match the pattern;note that this is different from a zero-length match.

The optionalpos andendpos parameters have the same meaning as for thesearch() method.

>>>pattern=re.compile("o[gh]")>>>pattern.fullmatch("dog")# No match as "o" is not at the start of "dog".>>>pattern.fullmatch("ogre")# No match as not the full string matches.>>>pattern.fullmatch("doggie",1,3)# Matches within given limits.<re.Match object; span=(1, 3), match='og'>

Added in version 3.4.

Pattern.split(string,maxsplit=0)¶

Identical to thesplit() function, using the compiled pattern.

Pattern.findall(string[,pos[,endpos]])¶

Similar to thefindall() function, using the compiled pattern, butalso accepts optionalpos andendpos parameters that limit the searchregion like forsearch().

Pattern.finditer(string[,pos[,endpos]])¶

Similar to thefinditer() function, using the compiled pattern, butalso accepts optionalpos andendpos parameters that limit the searchregion like forsearch().

Pattern.sub(repl,string,count=0)¶

Identical to thesub() function, using the compiled pattern.

Pattern.subn(repl,string,count=0)¶

Identical to thesubn() function, using the compiled pattern.

Pattern.flags¶

The regex matching flags. This is a combination of the flags given tocompile(), any(?...) inline flags in the pattern, and implicitflags such asUNICODE if the pattern is a Unicode string.

Pattern.groups¶

The number of capturing groups in the pattern.

Pattern.groupindex¶

A dictionary mapping any symbolic group names defined by(?P<id>) to groupnumbers. The dictionary is empty if no symbolic groups were used in thepattern.

Pattern.pattern¶

The pattern string from which the pattern object was compiled.

Match Objects¶

Match objects always have a boolean value ofTrue.Sincematch() andsearch() returnNonewhen there is no match, you can test whether there was a match with a simpleif statement:

match=re.search(pattern,string)ifmatch:process(match)

classre.Match¶

Match object returned by successfulmatches andsearches.

Changed in version 3.9:re.Match supports[] to indicate a Unicode (str) or bytes match.SeeGeneric Alias Type.

Match.expand(template)¶

Return the string obtained by doing backslash substitution on the templatestringtemplate, as done by thesub() method.Escapes such as\n are converted to the appropriate characters,and numeric backreferences (\1,\2) and named backreferences(\g<1>,\g<name>) are replaced by the contents of thecorresponding group. The backreference\g<0> will bereplaced by the entire match.

Changed in version 3.5:Unmatched groups are replaced with an empty string.

Match.group([group1,...])¶

Returns one or more subgroups of the match. If there is a single argument, theresult is a single string; if there are multiple arguments, the result is atuple with one item per argument. Without arguments,group1 defaults to zero(the whole match is returned). If agroupN argument is zero, the correspondingreturn value is the entire matching string; if it is in the inclusive range[1..99], it is the string matching the corresponding parenthesized group. If agroup number is negative or larger than the number of groups defined in thepattern, anIndexError exception is raised. If a group is contained in apart of the pattern that did not match, the corresponding result isNone.If a group is contained in a part of the pattern that matched multiple times,the last match is returned.

>>>m=re.match(r"(\w+) (\w+)","Isaac Newton, physicist")>>>m.group(0)# The entire match'Isaac Newton'>>>m.group(1)# The first parenthesized subgroup.'Isaac'>>>m.group(2)# The second parenthesized subgroup.'Newton'>>>m.group(1,2)# Multiple arguments give us a tuple.('Isaac', 'Newton')

If the regular expression uses the(?P<name>...) syntax, thegroupNarguments may also be strings identifying groups by their group name. If astring argument is not used as a group name in the pattern, anIndexErrorexception is raised.

A moderately complicated example:

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

Named groups can also be referred to by their index:

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

If a group matches multiple times, only the last match is accessible:

>>>m=re.match(r"(..)+","a1b2c3")# Matches 3 times.>>>m.group(1)# Returns only the last match.'c3'

Match.__getitem__(g)¶

This is identical tom.group(g). This allows easier access toan individual group from a match:

>>>m=re.match(r"(\w+) (\w+)","Isaac Newton, physicist")>>>m[0]# The entire match'Isaac Newton'>>>m[1]# The first parenthesized subgroup.'Isaac'>>>m[2]# The second parenthesized subgroup.'Newton'

Named groups are supported as well:

>>>m=re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)","Isaac Newton")>>>m['first_name']'Isaac'>>>m['last_name']'Newton'

Added in version 3.6.

Match.groups(default=None)¶

Return a tuple containing all the subgroups of the match, from 1 up to howevermany groups are in the pattern. Thedefault argument is used for groups thatdid not participate in the match; it defaults toNone.

For example:

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

If we make the decimal place and everything after it optional, not all groupsmight participate in the match. These groups will default toNone unlessthedefault argument is given:

>>>m=re.match(r"(\d+)\.?(\d+)?","24")>>>m.groups()# Second group defaults to None.('24', None)>>>m.groups('0')# Now, the second group defaults to '0'.('24', '0')

Match.groupdict(default=None)¶

Return a dictionary containing all thenamed subgroups of the match, keyed bythe subgroup name. Thedefault argument is used for groups that did notparticipate in the match; it defaults toNone. For example:

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

Match.start([group])¶

Match.end([group])¶

Return the indices of the start and end of the substring matched bygroup;group defaults to zero (meaning the whole matched substring). Return-1 ifgroup exists but did not contribute to the match. For a match objectm, anda groupg that did contribute to the match, the substring matched by groupg(equivalent tom.group(g)) is

m.string[m.start(g):m.end(g)]

Note thatm.start(group) will equalm.end(group) ifgroup matched anull string. For example, afterm=re.search('b(c?)','cba'),m.start(0) is 1,m.end(0) is 2,m.start(1) andm.end(1) are both2, andm.start(2) raises anIndexError exception.

An example that will removeremove_this from email addresses:

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

Match.span([group])¶

For a matchm, return the 2-tuple(m.start(group),m.end(group)). Notethat ifgroup did not contribute to the match, this is(-1,-1).group defaults to zero, the entire match.

Match.pos¶

The value ofpos which was passed to thesearch() ormatch() method of aregex object. This isthe index into the string at which the RE engine started looking for a match.

Match.endpos¶

The value ofendpos which was passed to thesearch() ormatch() method of aregex object. This isthe index into the string beyond which the RE engine will not go.

Match.lastindex¶

The integer index of the last matched capturing group, orNone if no groupwas matched at all. For example, the expressions(a)b,((a)(b)), and((ab)) will havelastindex==1 if applied to the string'ab', whilethe expression(a)(b) will havelastindex==2, if applied to the samestring.

Match.lastgroup¶

The name of the last matched capturing group, orNone if the group didn’thave a name, or if no group was matched at all.

Match.re¶

Theregular expression object whosematch() orsearch() method produced this match instance.

Match.string¶

The string passed tomatch() orsearch().

Regular Expression Examples¶

defdisplaymatch(match):ifmatchisNone:returnNonereturn'<Match:%r, groups=%r>'%(match.group(),match.groups())

>>>valid=re.compile(r"^[a2-9tjqk]{5}$")>>>displaymatch(valid.match("akt5q"))# Valid."<Match: 'akt5q', groups=()>">>>displaymatch(valid.match("akt5e"))# Invalid.>>>displaymatch(valid.match("akt"))# Invalid.>>>displaymatch(valid.match("727ak"))# Valid."<Match: '727ak', groups=()>"

>>>pair=re.compile(r".*(.).*\1")>>>displaymatch(pair.match("717ak"))# Pair of 7s."<Match: '717', groups=('7',)>">>>displaymatch(pair.match("718ak"))# No pairs.>>>displaymatch(pair.match("354aa"))# Pair of aces."<Match: '354aa', groups=('a',)>"

>>>pair=re.compile(r".*(.).*\1")>>>pair.match("717ak").group(1)'7'# Error because re.match() returns None, which doesn't have a group() method:>>>pair.match("718ak").group(1)Traceback (most recent call last):  File"<pyshell#23>", line1, in<module>re.match(r".*(.).*\1","718ak").group(1)AttributeError:'NoneType' object has no attribute 'group'>>>pair.match("354aa").group(1)'a'

/usr/sbin/sendmail-0errors,4warnings

%s-%derrors,%dwarnings

(\S+)-(\d+)errors,(\d+)warnings

>>>re.match("c","abcdef")# No match>>>re.search("c","abcdef")# Match<re.Match object; span=(2, 3), match='c'>>>>re.fullmatch("p.*n","python")# Match<re.Match object; span=(0, 6), match='python'>>>>re.fullmatch("r.*n","python")# No match

>>>re.match("c","abcdef")# No match>>>re.search("^c","abcdef")# No match>>>re.search("^a","abcdef")# Match<re.Match object; span=(0, 1), match='a'>

>>>re.match("X","A\nB\nX",re.MULTILINE)# No match>>>re.search("^X","A\nB\nX",re.MULTILINE)# Match<re.Match object; span=(4, 5), match='X'>

>>>text="""Ross McFluff: 834.345.1254 155 Elm Street......Ronald Heathmore: 892.345.3428 436 Finley Avenue...Frank Burger: 925.541.7625 662 South Dogwood Way.........Heather Albrecht: 548.326.4584 919 Park Place"""

>>>entries=re.split("\n+",text)>>>entries['Ross McFluff: 834.345.1254 155 Elm Street','Ronald Heathmore: 892.345.3428 436 Finley Avenue','Frank Burger: 925.541.7625 662 South Dogwood Way','Heather Albrecht: 548.326.4584 919 Park Place']

>>>[re.split(":? ",entry,maxsplit=3)forentryinentries][['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

>>>[re.split(":? ",entry,maxsplit=4)forentryinentries][['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

>>>defrepl(m):...inner_word=list(m.group(2))...random.shuffle(inner_word)...returnm.group(1)+"".join(inner_word)+m.group(3)...>>>text="Professor Abdolmalek, please report your absences promptly.">>>re.sub(r"(\w)(\w+)(\w)",repl,text)'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'>>>re.sub(r"(\w)(\w+)(\w)",repl,text)'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

>>>text="He was carefully disguised but captured quickly by police.">>>re.findall(r"\w+ly\b",text)['carefully', 'quickly']

>>>text="He was carefully disguised but captured quickly by police.">>>forminre.finditer(r"\w+ly\b",text):...print('%02d-%02d:%s'%(m.start(),m.end(),m.group(0)))07-16: carefully40-47: quickly

>>>re.match(r"\W(.)\1\W"," ff ")<re.Match object; span=(0, 4), match=' ff '>>>>re.match("\\W(.)\\1\\W"," ff ")<re.Match object; span=(0, 4), match=' ff '>

>>>re.match(r"\\",r"\\")<re.Match object; span=(0, 1), match='\\'>>>>re.match("\\\\",r"\\")<re.Match object; span=(0, 1), match='\\'>

fromtypingimportNamedTupleimportreclassToken(NamedTuple):type:strvalue:strline:intcolumn:intdeftokenize(code):keywords={'IF','THEN','ENDIF','FOR','NEXT','GOSUB','RETURN'}token_specification=[('NUMBER',r'\d+(\.\d*)?'),# Integer or decimal number('ASSIGN',r':='),# Assignment operator('END',r';'),# Statement terminator('ID',r'[A-Za-z]+'),# Identifiers('OP',r'[+\-*/]'),# Arithmetic operators('NEWLINE',r'\n'),# Line endings('SKIP',r'[ \t]+'),# Skip over spaces and tabs('MISMATCH',r'.'),# Any other character]tok_regex='|'.join('(?P<%s>%s)'%pairforpairintoken_specification)line_num=1line_start=0formoinre.finditer(tok_regex,code):kind=mo.lastgroupvalue=mo.group()column=mo.start()-line_startifkind=='NUMBER':value=float(value)if'.'invalueelseint(value)elifkind=='ID'andvalueinkeywords:kind=valueelifkind=='NEWLINE':line_start=mo.end()line_num+=1continueelifkind=='SKIP':continueelifkind=='MISMATCH':raiseRuntimeError(f'{value!r} unexpected on line{line_num}')yieldToken(kind,value,line_num,column)statements='''    IF quantity THEN        total := total + price * quantity;        tax := price * 0.05;    ENDIF;'''fortokenintokenize(statements):print(token)

Token(type='IF',value='IF',line=2,column=4)Token(type='ID',value='quantity',line=2,column=7)Token(type='THEN',value='THEN',line=2,column=16)Token(type='ID',value='total',line=3,column=8)Token(type='ASSIGN',value=':=',line=3,column=14)Token(type='ID',value='total',line=3,column=17)Token(type='OP',value='+',line=3,column=23)Token(type='ID',value='price',line=3,column=25)Token(type='OP',value='*',line=3,column=31)Token(type='ID',value='quantity',line=3,column=33)Token(type='END',value=';',line=3,column=41)Token(type='ID',value='tax',line=4,column=8)Token(type='ASSIGN',value=':=',line=4,column=12)Token(type='ID',value='price',line=4,column=15)Token(type='OP',value='*',line=4,column=21)Token(type='NUMBER',value=0.05,line=4,column=23)Token(type='END',value=';',line=4,column=27)Token(type='ENDIF',value='ENDIF',line=5,column=4)Token(type='END',value=';',line=5,column=9)