A | |
all [Re.Mark] |
Return all the mark matched.
|
all [Re.Group] |
Return the empty string for each group which did not match
|
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
|
all_offset [Re.Group] |
Return
(-1,-1) for each group which did not match
|
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] | |
compare [Re.Mark] | |
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
|
equal [Re.Mark] | |
exec [Re_pcre] |
Equivalent to
Re.exec .
|
exec [Re] | exec re str matches str against the compiled expression re ,
and returns the matched groups if any.
|
exec_opt [Re] |
Similar to
Re.exec , but returns an option instead of using an exception.
|
exec_partial [Re] |
More detailed version of
exec_p
|
execp [Re] | |
extract [Re_pcre] | extract ~rex s executes rex on s and returns the matching groups.
|
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.Group] |
Raise
Not_found if the group did not match
|
get [Re] |
Same as
Re.Group.get .
|
get_all [Re] |
Same as
Re.Group.all .
|
get_all_ofs [Re] |
Same as
Re.Group.all_offset .
|
get_ofs [Re] |
Same as
Re.Group.offset .
|
get_substring [Re_pcre] |
Equivalent to
Re.Group.get .
|
get_substring_ofs [Re_pcre] |
Equivalent to
Re.Group.offset .
|
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] |
This version of
glob also recognizes the pattern {..,..}
|
globx' [Re_glob] |
This version of
glob' also recognizes 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 n th 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] |
Same as
Re.Mark.all .
|
marked [Re] |
Same as
Re.Mark.test .
|
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 n th 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 | |
offset [Re.Group] |
Raise
Not_found if the group did not match
|
opt [Re] |
0 or 1 matches
|
P | |
pmatch [Re_pcre] |
Equivalent to
Re.execp .
|
pp [Re.Group] | |
pp [Re] | |
pp_re [Re] | |
print [Re] | |
print_re [Re] |
Alias for
Re.pp_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 ~flags s creates the regexp s using the pcre syntax.
|
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] | re ~flags s compiles the regexp s using the pcre syntax.
|
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] | repn re i j matches re at least i times
and at most j times, bounds included.
|
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.Group] |
Return the start of the match.
|
start [Re] |
Initial position
|
stop [Re.Group] |
Return the end of the match.
|
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.Mark] |
Tell if a mark was matched.
|
test [Re.Group] |
Test whether a group matched
|
test [Re] |
Same as
Re.Group.test .
|
U | |
upper [Re] | |
W | |
whole_string [Re] |
Only matches the whole string
|
word [Re] |
Word
|
wordc [Re] | |
X | |
xdigit [Re] |