| A | |
| all [Re] | 
Repeatedly calls  Re.execon the given string, starting at given
    position and length. | 
| all_gen [Re] | 
Same as  Re.allbut returns a generator | 
| alnum [Re] | |
| alpha [Re] | |
| alt [Re] | 
Alternative
 | 
| any [Re] | 
Any character
 | 
| ascii [Re] | |
| B | |
| blank [Re] | |
| bol [Re] | 
Beginning of line
 | 
| bos [Re] | 
Beginning of string
 | 
| bounded_full_split [Re_str] | 
Same as  split_delimandbounded_split_delim, but returns
    the delimiters as well as the substrings contained between
    delimiters. | 
| bounded_split [Re_str] | 
Same as  split, but splits into at mostnsubstrings,
    wherenis the extra integer parameter. | 
| bounded_split_delim [Re_str] | 
Same as  splitandbounded_split, but occurrences of the
    delimiter at the beginning and at the end of the string are
    recognized and returned as empty strings in the result. | 
| bow [Re] | 
Beginning of word
 | 
| C | |
| case [Re] | 
Case sensitive matching
 | 
| char [Re] | |
| cntrl [Re] | |
| compile [Re_perl] | 
Regular expression compilation
 | 
| compile [Re_posix] | 
Regular expression compilation
 | 
| compile [Re_emacs] | 
Regular expression compilation
 | 
| compile [Re] | 
Compile a regular expression into an executable version that can be
    used to match strings, e.g.
 | 
| compile_pat [Re_perl] | 
(Same as  Re.compile) | 
| compile_pat [Re_posix] | compile ris defined asRe.compile (Re.longest r) | 
| compile_pat [Re_emacs] | 
Same as  Re.compile | 
| compl [Re] | 
Complement of union
 | 
| D | |
| diff [Re] | 
Difference of character sets
 | 
| digit [Re] | |
| E | |
| empty [Re] | 
Match nothing
 | 
| eol [Re] | 
End of line
 | 
| eos [Re] | 
End of string
 | 
| eow [Re] | 
End of word
 | 
| epsilon [Re] | 
Empty word
 | 
| exec [Re_pcre] | |
| exec [Re] | exec re strmatchesstragainst the compiled expressionre,
    and returns the matched groups if any. | 
| exec_partial [Re] | |
| execp [Re] | |
| extract [Re_pcre] | |
| F | |
| first [Re] | 
First match
 | 
| first_chars [Re_str] | first_chars s nreturns the firstncharacters ofs. | 
| full_split [Re_pcre] | |
| full_split [Re_str] | |
| G | |
| get [Re] | 
Raise  Not_foundif the group did not match | 
| get_all [Re] | 
Return the empty string for each group which did not match
 | 
| get_all_ofs [Re] | 
Return  (-1,-1)for each group which did not match | 
| get_ofs [Re] | 
Raise  Not_foundif the group did not match | 
| get_substring [Re_pcre] | |
| get_substring_ofs [Re_pcre] | |
| glob [Re_glob] | 
Implements the semantics of shells patterns.
 | 
| glob' [Re_glob] | 
Same, but allows to choose whether dots at the beginning of a
    file name need to be explicitly matched (true) or not (false)
 | 
| global_replace [Re_str] | global_replace regexp templ sreturns a string identical tos,
    except that all substrings ofsthat matchregexphave been
    replaced bytempl. | 
| global_substitute [Re_str] | global_substitute regexp subst sreturns a string identical
           tos, except that all substrings ofsthat matchregexphave been replaced by the result of functionsubst. | 
| globx [Re_glob] | |
| globx' [Re_glob] | 
These two functions also recognize the pattern {..,..}
 | 
| graph [Re] | |
| greedy [Re] | 
Greedy
 | 
| group [Re] | 
Delimit a group
 | 
| group_beginning [Re_str] | |
| group_end [Re_str] | group_beginning nreturns the position of the first character
    of the substring that was matched by thenth group of
    the regular expression. | 
| I | |
| inter [Re] | 
Intersection of character sets
 | 
| L | |
| last_chars [Re_str] | last_chars s nreturns the lastncharacters ofs. | 
| leol [Re] | 
Last end of line or end of string
 | 
| longest [Re] | 
Longest match
 | 
| lower [Re] | |
| M | |
| mark [Re] | 
Mark a regexp.
 | 
| mark_set [Re] | |
| marked [Re] | 
Tell if a mark was matched.
 | 
| match_beginning [Re_str] | |
| match_end [Re_str] | match_beginning ()returns the position of the first character
    of the substring that was matched bystring_match,search_forwardorsearch_backward. | 
| matched_group [Re_str] | matched_group n sreturns the substring ofsthat was matched
    by thenth group\(...\)of the regular expression during
    the lateststring_match,search_forwardorsearch_backward. | 
| matched_string [Re_str] | matched_string sreturns the substring ofsthat was matched
           by the lateststring_match,search_forwardorsearch_backward. | 
| matches [Re] | 
Same as  Re.all, but extracts the matched substring rather than
    returning the whole group. | 
| matches_gen [Re] | 
Same as  Re.matches, but returns a generator. | 
| N | |
| nest [Re] | 
when matching against  nest e, only the group matching in the
       last match of e will be considered as matching | 
| no_case [Re] | 
Case insensitive matching
 | 
| no_group [Re] | 
Remove all groups
 | 
| non_greedy [Re] | 
Non-greedy
 | 
| not_boundary [Re] | 
Not at a word boundary
 | 
| notnl [Re] | 
Any character but a newline
 | 
| O | |
| opt [Re] | 
0 or 1 matches
 | 
| P | |
| pmatch [Re_pcre] | |
| print [Re] | |
| print_re [Re] | |
| punct [Re] | |
| Q | |
| quote [Re_pcre] | |
| quote [Re_str] | Str.quote sreturns a regexp string that matches exactlysand nothing else. | 
| R | |
| re [Re_pcre] | |
| re [Re_perl] | 
Parsing of a Perl-style regular expression
 | 
| re [Re_posix] | 
Parsing of a Posix extended regular expression
 | 
| re [Re_emacs] | 
Parsing of an Emacs-style regular expression
 | 
| regexp [Re_pcre] | |
| regexp [Re_str] | 
Compile a regular expression.
 | 
| regexp_case_fold [Re_str] | 
Same as  regexp, but the compiled expression will match text
           in a case-insensitive way: uppercase and lowercase letters will
           be considered equivalent. | 
| regexp_string [Re_str] | |
| regexp_string_case_fold [Re_str] | Str.regexp_string sreturns a regular expression
    that matches exactlysand nothing else. | 
| rep [Re] | 
0 or more matches
 | 
| rep1 [Re] | 
1 or more matches
 | 
| replace [Re] | replace ~all re ~f siterates ons, and replaces every occurrence
    ofrewithf substringwheresubstringis the current match. | 
| replace_first [Re_str] | 
Same as  global_replace, except that only the first substring
   matching the regular expression is replaced. | 
| replace_matched [Re_str] | replace_matched repl sreturns the replacement textreplin which\1,\2, etc. | 
| replace_string [Re] | replace_string ~all re ~by siterates ons, and replaces every
    occurrence ofrewithby. | 
| repn [Re] | 
Repeated matches
 | 
| rg [Re] | 
Character ranges
 | 
| S | |
| search_backward [Re_str] | 
Same as  search_forward, but the search proceeds towards the
           beginning of the string. | 
| search_forward [Re_str] | search_forward r s startsearches the stringsfor a substring
           matching the regular expressionr. | 
| seq [Re] | 
Sequence
 | 
| set [Re] | 
Any character of the string
 | 
| shortest [Re] | 
Shortest match
 | 
| space [Re] | |
| split [Re_pcre] | |
| split [Re_str] | split r ssplitssinto substrings, taking as delimiters
    the substrings that matchr, and returns the list of substrings. | 
| split [Re] | split re ssplitssinto chunks separated byre. | 
| split_delim [Re_str] | |
| split_full [Re] | |
| split_full_gen [Re] | |
| split_gen [Re] | |
| start [Re] | 
Initial position
 | 
| stop [Re] | 
Final position
 | 
| str [Re] | |
| string_after [Re_str] | string_after s nreturns the substring of all characters ofsthat follow positionn(including the character at
    positionn). | 
| string_before [Re_str] | string_before s nreturns the substring of all characters ofsthat precede positionn(excluding the character at
   positionn). | 
| string_match [Re_str] | string_match r s starttests whether the characters insstarting at positionstartmatch the regular expressionr. | 
| string_partial_match [Re_str] | 
Similar to  string_match, but succeeds whenever the argument
           string is a prefix of a string that matches. | 
| substitute [Re_pcre] | |
| substitute_first [Re_str] | 
Same as  global_substitute, except that only the first substring
           matching the regular expression is replaced. | 
| T | |
| test [Re] | 
Test whether a group matched
 | 
| U | |
| upper [Re] | |
| W | |
| whole_string [Re] | 
Only matches the whole string
 | 
| word [Re] | 
Word
 | 
| wordc [Re] | |
| X | |
| xdigit [Re] |