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
nb_groups [Re.Group]

Returns the total number of groups defined - matched or not.

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

witness [Re]

witness r generates a string s such that execp (compile r) s is true

word [Re]

Word

wordc [Re]
X
xdigit [Re]