Index of values


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]
Similar to Re.exec, but returns true if the expression matches, and false if it doesn't
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]
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 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]
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 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
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]