A | |
| all [Re] |
Repeatedly calls
Re.exec on the given string, starting at given
position and length.
|
| all_gen [Re] |
Same as
Re.all but 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_delim and bounded_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 most n substrings,
where n is the extra integer parameter.
|
| bounded_split_delim [Re_str] |
Same as
split and bounded_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 r is defined as Re.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 str matches str against the compiled expression re,
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 n returns the first n characters of s.
|
| full_split [Re_pcre] | |
| full_split [Re_str] | |
G | |
| get [Re] |
Raise
Not_found if 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_found if 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 s returns a string identical to s,
except that all substrings of s that match regexp have been
replaced by templ.
|
| global_substitute [Re_str] | global_substitute regexp subst s returns a string identical
to s, except that all substrings of s that match regexp
have been replaced by the result of function subst.
|
| 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 n returns the position of the first character
of the substring that was matched by the nth group of
the regular expression.
|
I | |
| inter [Re] |
Intersection of character sets
|
L | |
| last_chars [Re_str] | last_chars s n returns the last n characters of s.
|
| 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 by string_match,
search_forward or search_backward.
|
| matched_group [Re_str] | matched_group n s returns the substring of s that was matched
by the nth group \(...\) of the regular expression during
the latest string_match, search_forward or search_backward.
|
| matched_string [Re_str] | matched_string s returns the substring of s that was matched
by the latest string_match, search_forward or search_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 s returns a regexp string that matches exactly
s and 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 s returns a regular expression
that matches exactly s and nothing else.
|
| rep [Re] |
0 or more matches
|
| rep1 [Re] |
1 or more matches
|
| replace [Re] | replace ~all re ~f s iterates on s, and replaces every occurrence
of re with f substring where substring is 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 s returns the replacement text repl
in which \1, \2, etc.
|
| replace_string [Re] | replace_string ~all re ~by s iterates on s, and replaces every
occurrence of re with by.
|
| 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 start searches the string s for a substring
matching the regular expression r.
|
| seq [Re] |
Sequence
|
| set [Re] |
Any character of the string
|
| shortest [Re] |
Shortest match
|
| space [Re] | |
| split [Re_pcre] | |
| split [Re_str] | split r s splits s into substrings, taking as delimiters
the substrings that match r, and returns the list of substrings.
|
| split [Re] | split re s splits s into chunks separated by re.
|
| 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 n returns the substring of all characters of s
that follow position n (including the character at
position n).
|
| string_before [Re_str] | string_before s n returns the substring of all characters of s
that precede position n (excluding the character at
position n).
|
| string_match [Re_str] | string_match r s start tests whether the characters in s
starting at position start match the regular expression r.
|
| 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] |