Newer
Older
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="Docutils 0.21.2: https://docutils.sourceforge.io/" />
<style type="text/css">
/*
:Author: David Goodger (goodger@python.org)
:Id: $Id: html4css1.css 9511 2024-01-13 09:50:07Z milde $
:Copyright: This stylesheet has been placed in the public domain.
Default cascading style sheet for the HTML output of Docutils.
Despite the name, some widely supported CSS2 features are used.
See https://docutils.sourceforge.io/docs/howto/html-stylesheets.html for how to
customize this style sheet.
*/
/* used to remove borders from tables and images */
.borderless, table.borderless td, table.borderless th {
border: 0 }
table.borderless td, table.borderless th {
/* Override padding for "table.docutils td" with "! important".
The right padding separates the table cells. */
padding: 0 0.5em 0 0 ! important }
.first {
/* Override more specific margin styles with "! important". */
margin-top: 0 ! important }
.last, .with-subtitle {
margin-bottom: 0 ! important }
.hidden {
display: none }
.subscript {
vertical-align: sub;
font-size: smaller }
.superscript {
vertical-align: super;
font-size: smaller }
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
a.toc-backref {
text-decoration: none ;
color: black }
blockquote.epigraph {
margin: 2em 5em ; }
dl.docutils dd {
margin-bottom: 0.5em }
object[type="image/svg+xml"], object[type="application/x-shockwave-flash"] {
overflow: hidden;
}
/* Uncomment (and remove this text!) to get bold-faced definition list terms
dl.docutils dt {
font-weight: bold }
*/
div.abstract {
margin: 2em 5em }
div.abstract p.topic-title {
font-weight: bold ;
text-align: center }
div.admonition, div.attention, div.caution, div.danger, div.error,
div.hint, div.important, div.note, div.tip, div.warning {
margin: 2em ;
border: medium outset ;
padding: 1em }
div.admonition p.admonition-title, div.hint p.admonition-title,
div.important p.admonition-title, div.note p.admonition-title,
div.tip p.admonition-title {
font-weight: bold ;
font-family: sans-serif }
div.attention p.admonition-title, div.caution p.admonition-title,
div.danger p.admonition-title, div.error p.admonition-title,
div.warning p.admonition-title, .code .error {
color: red ;
font-weight: bold ;
font-family: sans-serif }
/* Uncomment (and remove this text!) to get reduced vertical space in
compound paragraphs.
div.compound .compound-first, div.compound .compound-middle {
margin-bottom: 0.5em }
div.compound .compound-last, div.compound .compound-middle {
margin-top: 0.5em }
*/
div.dedication {
margin: 2em 5em ;
text-align: center ;
font-style: italic }
div.dedication p.topic-title {
font-weight: bold ;
font-style: normal }
div.figure {
margin-left: 2em ;
margin-right: 2em }
div.footer, div.header {
clear: both;
font-size: smaller }
div.line-block {
display: block ;
margin-top: 1em ;
margin-bottom: 1em }
div.line-block div.line-block {
margin-top: 0 ;
margin-bottom: 0 ;
margin-left: 1.5em }
div.sidebar {
margin: 0 0 0.5em 1em ;
border: medium outset ;
padding: 1em ;
background-color: #ffffee ;
width: 40% ;
float: right ;
clear: right }
div.sidebar p.rubric {
font-family: sans-serif ;
font-size: medium }
div.system-messages {
margin: 5em }
div.system-messages h1 {
color: red }
div.system-message {
border: medium outset ;
padding: 1em }
div.system-message p.system-message-title {
color: red ;
font-weight: bold }
div.topic {
margin: 2em }
h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
margin-top: 0.4em }
h1.title {
text-align: center }
h2.subtitle {
text-align: center }
hr.docutils {
width: 75% }
img.align-left, .figure.align-left, object.align-left, table.align-left {
clear: left ;
float: left ;
margin-right: 1em }
img.align-right, .figure.align-right, object.align-right, table.align-right {
clear: right ;
float: right ;
margin-left: 1em }
img.align-center, .figure.align-center, object.align-center {
display: block;
margin-left: auto;
margin-right: auto;
}
table.align-center {
margin-left: auto;
margin-right: auto;
}
.align-left {
text-align: left }
.align-center {
clear: both ;
text-align: center }
.align-right {
text-align: right }
/* reset inner alignment in figures */
div.align-right {
text-align: inherit }
/* div.align-center * { */
/* text-align: left } */
.align-top {
vertical-align: top }
.align-middle {
vertical-align: middle }
.align-bottom {
vertical-align: bottom }
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
ol.simple, ul.simple {
margin-bottom: 1em }
ol.arabic {
list-style: decimal }
ol.loweralpha {
list-style: lower-alpha }
ol.upperalpha {
list-style: upper-alpha }
ol.lowerroman {
list-style: lower-roman }
ol.upperroman {
list-style: upper-roman }
p.attribution {
text-align: right ;
margin-left: 50% }
p.caption {
font-style: italic }
p.credits {
font-style: italic ;
font-size: smaller }
p.label {
white-space: nowrap }
p.rubric {
font-weight: bold ;
font-size: larger ;
color: maroon ;
text-align: center }
p.sidebar-title {
font-family: sans-serif ;
font-weight: bold ;
font-size: larger }
p.sidebar-subtitle {
font-family: sans-serif ;
font-weight: bold }
p.topic-title {
font-weight: bold }
pre.address {
margin-bottom: 0 ;
margin-top: 0 ;
font: inherit }
pre.literal-block, pre.doctest-block, pre.math, pre.code {
margin-left: 2em ;
margin-right: 2em }
pre.code .ln { color: gray; } /* line numbers */
pre.code, code { background-color: #eeeeee }
pre.code .comment, code .comment { color: #5C6576 }
pre.code .keyword, code .keyword { color: #3B0D06; font-weight: bold }
pre.code .literal.string, code .literal.string { color: #0C5404 }
pre.code .name.builtin, code .name.builtin { color: #352B84 }
pre.code .deleted, code .deleted { background-color: #DEB0A1}
pre.code .inserted, code .inserted { background-color: #A3D289}
span.classifier {
font-family: sans-serif ;
font-style: oblique }
span.classifier-delimiter {
font-family: sans-serif ;
font-weight: bold }
span.interpreted {
font-family: sans-serif }
span.option {
white-space: nowrap }
span.pre {
white-space: pre }
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
color: red }
span.section-subtitle {
/* font-size relative to parent (h1..h6 element) */
font-size: 80% }
table.citation {
border-left: solid 1px gray;
margin-left: 1px }
table.docinfo {
margin: 2em 4em }
table.docutils {
margin-top: 0.5em ;
margin-bottom: 0.5em }
table.footnote {
border-left: solid 1px black;
margin-left: 1px }
table.docutils td, table.docutils th,
table.docinfo td, table.docinfo th {
padding-left: 0.5em ;
padding-right: 0.5em ;
vertical-align: top }
table.docutils th.field-name, table.docinfo th.docinfo-name {
font-weight: bold ;
text-align: left ;
white-space: nowrap ;
padding-left: 0 }
/* "booktabs" style (no vertical lines) */
table.docutils.booktabs {
border: 0px;
border-top: 2px solid;
border-bottom: 2px solid;
border-collapse: collapse;
}
table.docutils.booktabs * {
border: 0px;
}
table.docutils.booktabs th {
border-bottom: thin solid;
text-align: left;
}
h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
font-size: 100% }
ul.auto-toc {
list-style-type: none }
</style>
</head>
<body>
<div class="document">
<div class="section" id="introduction">
<h1>Introduction</h1>
<p>This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality.</p>
</div>
<div class="section" id="python-2">
<h1>Python 2</h1>
<p>Python 2 is no longer supported. The last release that supported Python 2 was 2021.11.10.</p>
<div class="section" id="pypy">
<h1>PyPy</h1>
<p>This module is targeted at CPython. It expects that all codepoints are the same width, so it won't behave properly with PyPy outside U+0000..U+007F because PyPy stores strings as UTF-8.</p>
</div>
<div class="section" id="multithreading">
<h1>Multithreading</h1>
<p>The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument <tt class="docutils literal">concurrent=True</tt>. The behaviour is undefined if the string changes during matching, so use it <em>only</em> when it is guaranteed that that won't happen.</p>
</div>
<div class="section" id="unicode">
<h1>Unicode</h1>
<p>This module supports Unicode 16.0.0. Full Unicode case-folding is supported.</p>
</div>
<div class="section" id="flags">
<h1>Flags</h1>
<p>There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.</p>
<p>The scoped flags are: <tt class="docutils literal">ASCII <span class="pre">(?a)</span></tt>, <tt class="docutils literal">FULLCASE <span class="pre">(?f)</span></tt>, <tt class="docutils literal">IGNORECASE <span class="pre">(?i)</span></tt>, <tt class="docutils literal">LOCALE <span class="pre">(?L)</span></tt>, <tt class="docutils literal">MULTILINE <span class="pre">(?m)</span></tt>, <tt class="docutils literal">DOTALL <span class="pre">(?s)</span></tt>, <tt class="docutils literal">UNICODE <span class="pre">(?u)</span></tt>, <tt class="docutils literal">VERBOSE <span class="pre">(?x)</span></tt>, <tt class="docutils literal">WORD <span class="pre">(?w)</span></tt>.</p>
<p>The global flags are: <tt class="docutils literal">BESTMATCH <span class="pre">(?b)</span></tt>, <tt class="docutils literal">ENHANCEMATCH <span class="pre">(?e)</span></tt>, <tt class="docutils literal">POSIX <span class="pre">(?p)</span></tt>, <tt class="docutils literal">REVERSE <span class="pre">(?r)</span></tt>, <tt class="docutils literal">VERSION0 <span class="pre">(?V0)</span></tt>, <tt class="docutils literal">VERSION1 <span class="pre">(?V1)</span></tt>.</p>
<p>If neither the <tt class="docutils literal">ASCII</tt>, <tt class="docutils literal">LOCALE</tt> nor <tt class="docutils literal">UNICODE</tt> flag is specified, it will default to <tt class="docutils literal">UNICODE</tt> if the regex pattern is a Unicode string and <tt class="docutils literal">ASCII</tt> if it's a bytestring.</p>
<p>The <tt class="docutils literal">ENHANCEMATCH</tt> flag makes fuzzy matching attempt to improve the fit of the next match that it finds.</p>
<p>The <tt class="docutils literal">BESTMATCH</tt> flag makes fuzzy matching search for the best match instead of the next match.</p>
</div>
<div class="section" id="old-vs-new-behaviour">
<h1>Old vs new behaviour</h1>
<p>In order to be compatible with the re module, this module has 2 behaviours:</p>
<ul>
<li><p class="first"><strong>Version 0</strong> behaviour (old behaviour, compatible with the re module):</p>
<p>Please note that the re module's behaviour may change over time, and I'll endeavour to match that behaviour in version 0.</p>
<ul class="simple">
<li>Indicated by the <tt class="docutils literal">VERSION0</tt> flag.</li>
<li>Zero-width matches are not handled correctly in the re module before Python 3.7. The behaviour in those earlier versions is:<ul>
<li><tt class="docutils literal">.split</tt> won't split a string at a zero-width match.</li>
<li><tt class="docutils literal">.sub</tt> will advance by one character after a zero-width match.</li>
</ul>
</li>
<li>Inline flags apply to the entire pattern, and they can't be turned off.</li>
<li>Only simple sets are supported.</li>
<li>Case-insensitive matches in Unicode use simple case-folding by default.</li>
</ul>
</li>
<li><p class="first"><strong>Version 1</strong> behaviour (new behaviour, possibly different from the re module):</p>
<ul class="simple">
<li>Indicated by the <tt class="docutils literal">VERSION1</tt> flag.</li>
<li>Zero-width matches are handled correctly.</li>
<li>Inline flags apply to the end of the group or pattern, and they can be turned off.</li>
<li>Nested sets and set operations are supported.</li>
<li>Case-insensitive matches in Unicode use full case-folding by default.</li>
</ul>
</li>
</ul>
<p>If no version is specified, the regex module will default to <tt class="docutils literal">regex.DEFAULT_VERSION</tt>.</p>
</div>
<div class="section" id="case-insensitive-matches-in-unicode">
<h1>Case-insensitive matches in Unicode</h1>
<p>The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the <tt class="docutils literal">FULLCASE</tt> flag. Please note that this flag affects how the <tt class="docutils literal">IGNORECASE</tt> flag works; the <tt class="docutils literal">FULLCASE</tt> flag itself does not turn on case-insensitive matching.</p>
<p>Version 0 behaviour: the flag is off by default.</p>
<p>Version 1 behaviour: the flag is on by default.</p>
</div>
<div class="section" id="nested-sets-and-set-operations">
<h1>Nested sets and set operations</h1>
<p>It's not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped <tt class="docutils literal">"["</tt> in a set.</p>
<p>For example, the pattern <tt class="docutils literal"><span class="pre">[[a-z]--[aeiou]]</span></tt> is treated in the version 0 behaviour (simple sets, compatible with the re module) as:</p>
<ul class="simple">
<li>Set containing "[" and the letters "a" to "z"</li>
<li>Literal "--"</li>
<li>Set containing letters "a", "e", "i", "o", "u"</li>
</ul>
<p>but in the version 1 behaviour (nested sets, enhanced behaviour) as:</p>
<ul class="simple">
<li>Set which is:<ul>
<li>Set containing the letters "a" to "z"</li>
</ul>
</li>
<li>but excluding:<ul>
<li>Set containing the letters "a", "e", "i", "o", "u"</li>
</ul>
</li>
</ul>
<p>Version 0 behaviour: only simple sets are supported.</p>
<p>Version 1 behaviour: nested sets and set operations are supported.</p>
</div>
<div class="section" id="notes-on-named-groups">
<h1>Notes on named groups</h1>
<p>All groups have a group number, starting from 1.</p>
<p>Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.</p>
<p>The same name can be used by more than one group, with later captures 'overwriting' earlier captures. All the captures of the group will be available from the <tt class="docutils literal">captures</tt> method of the match object.</p>
<p>Group numbers will be reused across different branches of a branch reset, eg. <tt class="docutils literal"><span class="pre">(?|(first)|(second))</span></tt> has only group 1. If groups have different group names then they will, of course, have different group numbers, eg. <tt class="docutils literal"><span class="pre">(?|(?P<foo>first)|(?P<bar>second))</span></tt> has group 1 ("foo") and group 2 ("bar").</p>
<p>In the regex <tt class="docutils literal"><span class="pre">(\s+)(?|(?P<foo>[A-Z]+)|(\w+)</span> <span class="pre">(?P<foo>[0-9]+)</span></tt> there are 2 groups:</p>
<ul class="simple">
<li><tt class="docutils literal">(\s+)</tt> is group 1.</li>
<li><tt class="docutils literal"><span class="pre">(?P<foo>[A-Z]+)</span></tt> is group 2, also called "foo".</li>
<li><tt class="docutils literal">(\w+)</tt> is group 2 because of the branch reset.</li>
<li><tt class="docutils literal"><span class="pre">(?P<foo>[0-9]+)</span></tt> is group 2 because it's called "foo".</li>
</ul>
<p>If you want to prevent <tt class="docutils literal">(\w+)</tt> from being group 2, you need to name it (different name, different group number).</p>
</div>
<div class="section" id="additional-features">
<h1>Additional features</h1>
<p>The issue numbers relate to the Python bug tracker, except where listed otherwise.</p>
<div class="section" id="added-p-horiz-space-and-p-vert-space-github-issue-477">
<h2>Added <tt class="docutils literal">\p{Horiz_Space}</tt> and <tt class="docutils literal">\p{Vert_Space}</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/477#issuecomment-1216779547">GitHub issue 477</a>)</h2>
<p><tt class="docutils literal">\p{Horiz_Space}</tt> or <tt class="docutils literal">\p{H}</tt> matches horizontal whitespace and <tt class="docutils literal">\p{Vert_Space}</tt> or <tt class="docutils literal">\p{V}</tt> matches vertical whitespace.</p>
</div>
<div class="section" id="added-support-for-lookaround-in-conditional-pattern-hg-issue-163">
<h2>Added support for lookaround in conditional pattern (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/163">Hg issue 163</a>)</h2>
<p>The test of a conditional pattern can be a lookaround.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?(?=\d)\d+|\w+)'</span><span class="punctuation">,</span> <span class="literal string single">'123abc'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'123'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?(?=\d)\d+|\w+)'</span><span class="punctuation">,</span> <span class="literal string single">'abc123'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">6</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'abc123'</span><span class="operator">></span>
</pre>
<p>This is not quite the same as putting a lookaround in the first branch of a pair of alternatives.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?:(?=\d)\d+\b|\w+)'</span><span class="punctuation">,</span> <span class="literal string single">'123abc'</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">6</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'123abc'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?(?=\d)\d+\b|\w+)'</span><span class="punctuation">,</span> <span class="literal string single">'123abc'</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="keyword constant">None</span>
</pre>
<p>In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was <strong>not</strong> attempted.</p>
</div>
<div class="section" id="added-posix-matching-leftmost-longest-hg-issue-150">
<h2>Added POSIX matching (leftmost longest) (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/150">Hg issue 150</a>)</h2>
<p>The POSIX standard for regex is to return the leftmost longest match. This can be turned on using the <tt class="docutils literal">POSIX</tt> flag.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="comment single"># Normal matching.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'Mr|Mrs'</span><span class="punctuation">,</span> <span class="literal string single">'Mrs'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'Mr'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'one(self)?(selfsufficient)?'</span><span class="punctuation">,</span> <span class="literal string single">'oneselfsufficient'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">7</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'oneself'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># POSIX matching.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?p)Mr|Mrs'</span><span class="punctuation">,</span> <span class="literal string single">'Mrs'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'Mrs'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?p)one(self)?(selfsufficient)?'</span><span class="punctuation">,</span> <span class="literal string single">'oneselfsufficient'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">17</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'oneselfsufficient'</span><span class="operator">></span>
</pre>
<p>Note that it will take longer to find matches because when it finds a match at a certain position, it won't return that immediately, but will keep looking to see if there's another longer match there.</p>
</div>
<div class="section" id="added-define-hg-issue-152">
<h2>Added <tt class="docutils literal"><span class="pre">(?(DEFINE)...)</span></tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/152">Hg issue 152</a>)</h2>
<p>If there's no group called "DEFINE", then ... will be ignored except that any groups defined within it can be called and that the normal rules for numbering groups still apply.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?(DEFINE)(?P<quant>\d+)(?P<item>\w+))(?&quant) (?&item)'</span><span class="punctuation">,</span> <span class="literal string single">'5 elephants'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">11</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'5 elephants'</span><span class="operator">></span>
</div>
<div class="section" id="added-prune-skip-and-fail-hg-issue-153">
<h2>Added <tt class="docutils literal">(*PRUNE)</tt>, <tt class="docutils literal">(*SKIP)</tt> and <tt class="docutils literal">(*FAIL)</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/153">Hg issue 153</a>)</h2>
<p><tt class="docutils literal">(*PRUNE)</tt> discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.</p>
<p><tt class="docutils literal">(*SKIP)</tt> is similar to <tt class="docutils literal">(*PRUNE)</tt>, except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.</p>
<p><tt class="docutils literal">(*FAIL)</tt> causes immediate backtracking. <tt class="docutils literal">(*F)</tt> is a permitted abbreviation.</p>
</div>
<div class="section" id="added-k-hg-issue-151">
<h2>Added <tt class="docutils literal">\K</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/151">Hg issue 151</a>)</h2>
<p>Keeps the part of the entire match after the position where <tt class="docutils literal">\K</tt> occurred; the part before it is discarded.</p>
<p>It does not affect what groups return.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(\w\w\K\w\w\w)'</span><span class="punctuation">,</span> <span class="literal string single">'abcdef'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="punctuation">[</span><span class="literal number integer">0</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="literal string single">'cde'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="literal string single">'abcde'</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'(?r)(\w\w\K\w\w\w)'</span><span class="punctuation">,</span> <span class="literal string single">'abcdef'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="punctuation">[</span><span class="literal number integer">0</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="literal string single">'bc'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="literal string single">'bcdef'</span>
</div>
<div class="section" id="added-capture-subscripting-for-expandf-and-subf-subfn-hg-issue-133">
<h2>Added capture subscripting for <tt class="docutils literal">expandf</tt> and <tt class="docutils literal">subf</tt>/<tt class="docutils literal">subfn</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/133">Hg issue 133</a>)</h2>
<p>You can use subscripting to get the captures of a repeated group.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(\w)+"</span><span class="punctuation">,</span> <span class="literal string double">"abc"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{1}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'c'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{1[0]}</span><span class="literal string double"> </span><span class="literal string interpol">{1[1]}</span><span class="literal string double"> </span><span class="literal string interpol">{1[2]}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'a b c'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{1[-1]}</span><span class="literal string double"> </span><span class="literal string interpol">{1[-2]}</span><span class="literal string double"> </span><span class="literal string interpol">{1[-3]}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'c b a'</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<letter>\w)+"</span><span class="punctuation">,</span> <span class="literal string double">"abc"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{letter}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'c'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{letter[0]}</span><span class="literal string double"> </span><span class="literal string interpol">{letter[1]}</span><span class="literal string double"> </span><span class="literal string interpol">{letter[2]}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'a b c'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{letter[-1]}</span><span class="literal string double"> </span><span class="literal string interpol">{letter[-2]}</span><span class="literal string double"> </span><span class="literal string interpol">{letter[-3]}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'c b a'</span>
</div>
<div class="section" id="added-support-for-referring-to-a-group-by-number-using-p">
<h2>Added support for referring to a group by number using <tt class="docutils literal"><span class="pre">(?P=...)</span></tt></h2>
<p>This is in addition to the existing <tt class="docutils literal"><span class="pre">\g<...></span></tt>.</p>
</div>
<div class="section" id="fixed-the-handling-of-locale-sensitive-regexes">
<h2>Fixed the handling of locale-sensitive regexes</h2>
<p>The <tt class="docutils literal">LOCALE</tt> flag is intended for legacy code and has limited support. You're still recommended to use Unicode instead.</p>
</div>
<div class="section" id="added-partial-matches-hg-issue-102">
<h2>Added partial matches (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/102">Hg issue 102</a>)</h2>
<p>A partial match is one that matches up to the end of string, but that string has been truncated and you want to know whether a complete match could be possible if the string had not been truncated.</p>
<p>Partial matches are supported by <tt class="docutils literal">match</tt>, <tt class="docutils literal">search</tt>, <tt class="docutils literal">fullmatch</tt> and <tt class="docutils literal">finditer</tt> with the <tt class="docutils literal">partial</tt> keyword argument.</p>
<p>Match objects have a <tt class="docutils literal">partial</tt> attribute, which is <tt class="docutils literal">True</tt> if it's a partial match.</p>
<p>For example, if you wanted a user to enter a 4-digit number and check it character by character as it was being entered:</p>
<pre class="code python literal-block">
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
<span class="operator">>>></span> <span class="name">pattern</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string single">'\d</span><span class="literal string interpol">{4}</span><span class="literal string single">'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Initially, nothing has been entered:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">''</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">0</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">''</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># An empty string is OK, but it's only a partial match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># The user enters a letter:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">'a'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="keyword constant">None</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># It'll never match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># The user deletes that and enters a digit:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">'1'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'1'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># It matches this far, but it's only a partial match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># The user enters 2 more digits:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">'123'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'123'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># It matches this far, but it's only a partial match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># The user enters another digit:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">'1234'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">4</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'1234'</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># It's a complete match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># If the user enters another digit:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">pattern</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string single">'12345'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="keyword constant">None</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># It's no longer a match.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># This is a partial match:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">pattern</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string single">'123'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">partial</span><span class="whitespace">
</span><span class="keyword constant">True</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># This is a complete match:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">pattern</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string single">'1233'</span><span class="punctuation">,</span> <span class="name">partial</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">partial</span><span class="whitespace">
</span><span class="keyword constant">False</span>
</div>
<div class="section" id="operator-not-working-correctly-with-sub-hg-issue-106">
<h2><tt class="docutils literal">*</tt> operator not working correctly with sub() (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/106">Hg issue 106</a>)</h2>
<p>Sometimes it's not clear how zero-width matches should be handled. For example, should <tt class="docutils literal">.*</tt> match 0 characters directly after matching >0 characters?</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">sub</span><span class="punctuation">(</span><span class="literal string single">'.*'</span><span class="punctuation">,</span> <span class="literal string single">'x'</span><span class="punctuation">,</span> <span class="literal string single">'test'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'xx'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">sub</span><span class="punctuation">(</span><span class="literal string single">'.*?'</span><span class="punctuation">,</span> <span class="literal string single">'|'</span><span class="punctuation">,</span> <span class="literal string single">'test'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'|||||||||'</span>
</div>
<div class="section" id="added-capturesdict-hg-issue-86">
<h2>Added <tt class="docutils literal">capturesdict</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/86">Hg issue 86</a>)</h2>
<p><tt class="docutils literal">capturesdict</tt> is a combination of <tt class="docutils literal">groupdict</tt> and <tt class="docutils literal">captures</tt>:</p>
<p><tt class="docutils literal">groupdict</tt> returns a dict of the named groups and the last capture of those groups.</p>
<p><tt class="docutils literal">captures</tt> returns a list of all the captures of a group</p>
<p><tt class="docutils literal">capturesdict</tt> returns a dict of the named groups and lists of all the captures of those groups.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?:(?P<word>\w+) (?P<digits>\d+)\n)+"</span><span class="punctuation">,</span> <span class="literal string double">"one 1</span><span class="literal string escape">\n</span><span class="literal string double">two 2</span><span class="literal string escape">\n</span><span class="literal string double">three 3</span><span class="literal string escape">\n</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">groupdict</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">{</span><span class="literal string single">'word'</span><span class="punctuation">:</span> <span class="literal string single">'three'</span><span class="punctuation">,</span> <span class="literal string single">'digits'</span><span class="punctuation">:</span> <span class="literal string single">'3'</span><span class="punctuation">}</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"word"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'one'</span><span class="punctuation">,</span> <span class="literal string single">'two'</span><span class="punctuation">,</span> <span class="literal string single">'three'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"digits"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'1'</span><span class="punctuation">,</span> <span class="literal string single">'2'</span><span class="punctuation">,</span> <span class="literal string single">'3'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">capturesdict</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">{</span><span class="literal string single">'word'</span><span class="punctuation">:</span> <span class="punctuation">[</span><span class="literal string single">'one'</span><span class="punctuation">,</span> <span class="literal string single">'two'</span><span class="punctuation">,</span> <span class="literal string single">'three'</span><span class="punctuation">],</span> <span class="literal string single">'digits'</span><span class="punctuation">:</span> <span class="punctuation">[</span><span class="literal string single">'1'</span><span class="punctuation">,</span> <span class="literal string single">'2'</span><span class="punctuation">,</span> <span class="literal string single">'3'</span><span class="punctuation">]}</span>
<div class="section" id="added-allcaptures-and-allspans-git-issue-474">
<h2>Added <tt class="docutils literal">allcaptures</tt> and <tt class="docutils literal">allspans</tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/474">Git issue 474</a>)</h2>
<p><tt class="docutils literal">allcaptures</tt> returns a list of all the captures of all the groups.</p>
<p><tt class="docutils literal">allspans</tt> returns a list of all the spans of the all captures of all the groups.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?:(?P<word>\w+) (?P<digits>\d+)\n)+"</span><span class="punctuation">,</span> <span class="literal string double">"one 1</span><span class="literal string escape">\n</span><span class="literal string double">two 2</span><span class="literal string escape">\n</span><span class="literal string double">three 3</span><span class="literal string escape">\n</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">allcaptures</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">([</span><span class="literal string single">'one 1</span><span class="literal string escape">\n</span><span class="literal string single">two 2</span><span class="literal string escape">\n</span><span class="literal string single">three 3</span><span class="literal string escape">\n</span><span class="literal string single">'</span><span class="punctuation">],</span> <span class="punctuation">[</span><span class="literal string single">'one'</span><span class="punctuation">,</span> <span class="literal string single">'two'</span><span class="punctuation">,</span> <span class="literal string single">'three'</span><span class="punctuation">],</span> <span class="punctuation">[</span><span class="literal string single">'1'</span><span class="punctuation">,</span> <span class="literal string single">'2'</span><span class="punctuation">,</span> <span class="literal string single">'3'</span><span class="punctuation">])</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">allspans</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">([(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">20</span><span class="punctuation">)],</span> <span class="punctuation">[(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">),</span> <span class="punctuation">(</span><span class="literal number integer">6</span><span class="punctuation">,</span> <span class="literal number integer">9</span><span class="punctuation">),</span> <span class="punctuation">(</span><span class="literal number integer">12</span><span class="punctuation">,</span> <span class="literal number integer">17</span><span class="punctuation">)],</span> <span class="punctuation">[(</span><span class="literal number integer">4</span><span class="punctuation">,</span> <span class="literal number integer">5</span><span class="punctuation">),</span> <span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">,</span> <span class="literal number integer">11</span><span class="punctuation">),</span> <span class="punctuation">(</span><span class="literal number integer">18</span><span class="punctuation">,</span> <span class="literal number integer">19</span><span class="punctuation">)])</span>
<div class="section" id="allow-duplicate-names-of-groups-hg-issue-87">
<h2>Allow duplicate names of groups (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/87">Hg issue 87</a>)</h2>
<pre class="code python literal-block">
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
<span class="operator">>>></span> <span class="comment single"># With optional groups:</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Both groups capture, the second capture 'overwriting' the first.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w+)? or (?P<item>\w+)?"</span><span class="punctuation">,</span> <span class="literal string double">"first or second"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'second'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'first'</span><span class="punctuation">,</span> <span class="literal string single">'second'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Only the second group captures.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w+)? or (?P<item>\w+)?"</span><span class="punctuation">,</span> <span class="literal string double">" or second"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'second'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'second'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Only the first group captures.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w+)? or (?P<item>\w+)?"</span><span class="punctuation">,</span> <span class="literal string double">"first or "</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'first'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'first'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># With mandatory groups:</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Both groups capture, the second capture 'overwriting' the first.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w*) or (?P<item>\w*)?"</span><span class="punctuation">,</span> <span class="literal string double">"first or second"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'second'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'first'</span><span class="punctuation">,</span> <span class="literal string single">'second'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># Again, both groups capture, the second capture 'overwriting' the first.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w*) or (?P<item>\w*)"</span><span class="punctuation">,</span> <span class="literal string double">" or second"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'second'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">''</span><span class="punctuation">,</span> <span class="literal string single">'second'</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># And yet again, both groups capture, the second capture 'overwriting' the first.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<item>\w*) or (?P<item>\w*)"</span><span class="punctuation">,</span> <span class="literal string double">"first or "</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">''</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">captures</span><span class="punctuation">(</span><span class="literal string double">"item"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">[</span><span class="literal string single">'first'</span><span class="punctuation">,</span> <span class="literal string single">''</span><span class="punctuation">]</span>
</div>
<div class="section" id="added-fullmatch-issue-16203">
<h2>Added <tt class="docutils literal">fullmatch</tt> (<a class="reference external" href="https://bugs.python.org/issue16203">issue #16203</a>)</h2>
<p><tt class="docutils literal">fullmatch</tt> behaves like <tt class="docutils literal">match</tt>, except that it must match all of the string.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"abc"</span><span class="punctuation">,</span> <span class="literal string double">"abc"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">span</span><span class="punctuation">())</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"abc"</span><span class="punctuation">,</span> <span class="literal string double">"abcx"</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="keyword constant">None</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"abc"</span><span class="punctuation">,</span> <span class="literal string double">"abcx"</span><span class="punctuation">,</span> <span class="name">endpos</span><span class="operator">=</span><span class="literal number integer">3</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">span</span><span class="punctuation">())</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"abc"</span><span class="punctuation">,</span> <span class="literal string double">"xabcy"</span><span class="punctuation">,</span> <span class="name">pos</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">,</span> <span class="name">endpos</span><span class="operator">=</span><span class="literal number integer">4</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">span</span><span class="punctuation">())</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">1</span><span class="punctuation">,</span> <span class="literal number integer">4</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"a.*?"</span><span class="punctuation">,</span> <span class="literal string double">"abcd"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'a'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"a.*?"</span><span class="punctuation">,</span> <span class="literal string double">"abcd"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'abcd'</span>
</div>
<div class="section" id="added-subf-and-subfn">
<h2>Added <tt class="docutils literal">subf</tt> and <tt class="docutils literal">subfn</tt></h2>
<p><tt class="docutils literal">subf</tt> and <tt class="docutils literal">subfn</tt> are alternatives to <tt class="docutils literal">sub</tt> and <tt class="docutils literal">subn</tt> respectively. When passed a replacement string, they treat it as a format string.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">subf</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(\w+) (\w+)"</span><span class="punctuation">,</span> <span class="literal string double">"</span><span class="literal string interpol">{0}</span><span class="literal string double"> => </span><span class="literal string interpol">{2}</span><span class="literal string double"> </span><span class="literal string interpol">{1}</span><span class="literal string double">"</span><span class="punctuation">,</span> <span class="literal string double">"foo bar"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo bar => bar foo'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">subf</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<word1>\w+) (?P<word2>\w+)"</span><span class="punctuation">,</span> <span class="literal string double">"</span><span class="literal string interpol">{word2}</span><span class="literal string double"> </span><span class="literal string interpol">{word1}</span><span class="literal string double">"</span><span class="punctuation">,</span> <span class="literal string double">"foo bar"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'bar foo'</span>
</div>
<div class="section" id="added-expandf-to-match-object">
<h2>Added <tt class="docutils literal">expandf</tt> to match object</h2>
<p><tt class="docutils literal">expandf</tt> is an alternative to <tt class="docutils literal">expand</tt>. When passed a replacement string, it treats it as a format string.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(\w+) (\w+)"</span><span class="punctuation">,</span> <span class="literal string double">"foo bar"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{0}</span><span class="literal string double"> => </span><span class="literal string interpol">{2}</span><span class="literal string double"> </span><span class="literal string interpol">{1}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo bar => bar foo'</span><span class="whitespace">
</span><span class="operator">>>></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?P<word1>\w+) (?P<word2>\w+)"</span><span class="punctuation">,</span> <span class="literal string double">"foo bar"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">expandf</span><span class="punctuation">(</span><span class="literal string double">"</span><span class="literal string interpol">{word2}</span><span class="literal string double"> </span><span class="literal string interpol">{word1}</span><span class="literal string double">"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'bar foo'</span>
</div>
<div class="section" id="detach-searched-string">
<h2>Detach searched string</h2>
<p>A match object contains a reference to the string that was searched, via its <tt class="docutils literal">string</tt> attribute. The <tt class="docutils literal">detach_string</tt> method will 'detach' that string, making it available for garbage collection, which might save valuable memory if that string is very large.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"\w+"</span><span class="punctuation">,</span> <span class="literal string double">"Hello world"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">())</span><span class="whitespace">
</span><span class="name">Hello</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">m</span><span class="operator">.</span><span class="name">string</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="name">Hello</span> <span class="name">world</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">detach_string</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">())</span><span class="whitespace">
</span><span class="name">Hello</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">m</span><span class="operator">.</span><span class="name">string</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="keyword constant">None</span>
</div>
<div class="section" id="recursive-patterns-hg-issue-27">
<h2>Recursive patterns (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/27">Hg issue 27</a>)</h2>
<p>Recursive and repeated patterns are supported.</p>
<p><tt class="docutils literal"><span class="pre">(?R)</span></tt> or <tt class="docutils literal"><span class="pre">(?0)</span></tt> tries to match the entire regex recursively. <tt class="docutils literal"><span class="pre">(?1)</span></tt>, <tt class="docutils literal"><span class="pre">(?2)</span></tt>, etc, try to match the relevant group.</p>
<p><tt class="docutils literal"><span class="pre">(?&name)</span></tt> tries to match the named group.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(Tarzan|Jane) loves (?1)"</span><span class="punctuation">,</span> <span class="literal string double">"Tarzan loves Jane"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">groups</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal string single">'Tarzan'</span><span class="punctuation">,)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(Tarzan|Jane) loves (?1)"</span><span class="punctuation">,</span> <span class="literal string double">"Jane loves Tarzan"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">groups</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal string single">'Jane'</span><span class="punctuation">,)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(\w)(?:(?R)|(\w?))\1"</span><span class="punctuation">,</span> <span class="literal string double">"kayak"</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">group</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal string single">'kayak'</span><span class="punctuation">,</span> <span class="literal string single">'k'</span><span class="punctuation">,</span> <span class="keyword constant">None</span><span class="punctuation">)</span>
<p>The first two examples show how the subpattern within the group is reused, but is _not_ itself a group. In other words, <tt class="docutils literal">"(Tarzan|Jane) loves <span class="pre">(?1)"</span></tt> is equivalent to <tt class="docutils literal">"(Tarzan|Jane) loves <span class="pre">(?:Tarzan|Jane)"</span></tt>.</p>
<p>It's possible to backtrack into a recursed or repeated group.</p>
<p>You can't call a group if there is more than one group with that group name or group number (<tt class="docutils literal">"ambiguous group reference"</tt>).</p>
<p>The alternative forms <tt class="docutils literal"><span class="pre">(?P>name)</span></tt> and <tt class="docutils literal"><span class="pre">(?P&name)</span></tt> are also supported.</p>
</div>
<div class="section" id="full-unicode-case-folding-is-supported">
<h2>Full Unicode case-folding is supported</h2>
<p>In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?iV1)strasse"</span><span class="punctuation">,</span> <span class="literal string double">"stra</span><span class="literal string escape">\N{LATIN SMALL LETTER SHARP S}</span><span class="literal string double">e"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">span</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">6</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">match</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e"</span><span class="punctuation">,</span> <span class="literal string double">"STRASSE"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">span</span><span class="punctuation">()</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">7</span><span class="punctuation">)</span>
</pre>
<p>In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module.</p>
</div>
<div class="section" id="approximate-fuzzy-matching-hg-issue-12-hg-issue-41-hg-issue-109">
<h2>Approximate "fuzzy" matching (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/12">Hg issue 12</a>, <a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/41">Hg issue 41</a>, <a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/109">Hg issue 109</a>)</h2>
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
<p>Regex usually attempts an exact match, but sometimes an approximate, or "fuzzy", match is needed, for those cases where the text being searched may contain errors in the form of inserted, deleted or substituted characters.</p>
<p>A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.)</p>
<p>The 3 types of error are:</p>
<ul class="simple">
<li>Insertion, indicated by "i"</li>
<li>Deletion, indicated by "d"</li>
<li>Substitution, indicated by "s"</li>
</ul>
<p>In addition, "e" indicates any type of error.</p>
<p>The fuzziness of a regex item is specified between "{" and "}" after the item.</p>
<p>Examples:</p>
<ul class="simple">
<li><tt class="docutils literal">foo</tt> match "foo" exactly</li>
<li><tt class="docutils literal"><span class="pre">(?:foo){i}</span></tt> match "foo", permitting insertions</li>
<li><tt class="docutils literal"><span class="pre">(?:foo){d}</span></tt> match "foo", permitting deletions</li>
<li><tt class="docutils literal"><span class="pre">(?:foo){s}</span></tt> match "foo", permitting substitutions</li>
<li><tt class="docutils literal"><span class="pre">(?:foo){i,s}</span></tt> match "foo", permitting insertions and substitutions</li>
<li><tt class="docutils literal"><span class="pre">(?:foo){e}</span></tt> match "foo", permitting errors</li>
</ul>
<p>If a certain type of error is specified, then any type not specified will <strong>not</strong> be permitted.</p>
<p>In the following examples I'll omit the item and write only the fuzziness:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">{d<=3}</span></tt> permit at most 3 deletions, but no other types</li>
<li><tt class="docutils literal"><span class="pre">{i<=1,s<=2}</span></tt> permit at most 1 insertion and at most 2 substitutions, but no deletions</li>
<li><tt class="docutils literal"><span class="pre">{1<=e<=3}</span></tt> permit at least 1 and at most 3 errors</li>
<li><tt class="docutils literal"><span class="pre">{i<=2,d<=2,e<=3}</span></tt> permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions</li>
</ul>
<p>It's also possible to state the costs of each type of error and the maximum permitted total cost.</p>
<p>Examples:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">{2i+2d+1s<=4}</span></tt> each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4</li>
<li><tt class="docutils literal"><span class="pre">{i<=1,d<=1,s<=1,2i+2d+1s<=4}</span></tt> at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4</li>
</ul>
<p>You can also use "<" instead of "<=" if you want an exclusive minimum or maximum.</p>
<p>You can add a test to perform on a character that's substituted or inserted.</p>
<p>Examples:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">{s<=2:[a-z]}</span></tt> at most 2 substitutions, which must be in the character set <tt class="docutils literal"><span class="pre">[a-z]</span></tt>.</li>
<li><tt class="docutils literal"><span class="pre">{s<=2,i<=3:\d}</span></tt> at most 2 substitutions, at most 3 insertions, which must be digits.</li>
</ul>
<p>By default, fuzzy matching searches for the first match that meets the given constraints. The <tt class="docutils literal">ENHANCEMATCH</tt> flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found.</p>
<p>The <tt class="docutils literal">BESTMATCH</tt> flag will make it search for the best match instead.</p>
<p>Further examples to note:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">regex.search("(dog){e}",</span> "cat and <span class="pre">dog")[1]</span></tt> returns <tt class="docutils literal">"cat"</tt> because that matches <tt class="docutils literal">"dog"</tt> with 3 errors (an unlimited number of errors is permitted).</li>
<li><tt class="docutils literal"><span class="pre">regex.search("(dog){e<=1}",</span> "cat and <span class="pre">dog")[1]</span></tt> returns <tt class="docutils literal">" dog"</tt> (with a leading space) because that matches <tt class="docutils literal">"dog"</tt> with 1 error, which is within the limit.</li>
<li><tt class="docutils literal"><span class="pre">regex.search("(?e)(dog){e<=1}",</span> "cat and <span class="pre">dog")[1]</span></tt> returns <tt class="docutils literal">"dog"</tt> (without a leading space) because the fuzzy search matches <tt class="docutils literal">" dog"</tt> with 1 error, which is within the limit, and the <tt class="docutils literal"><span class="pre">(?e)</span></tt> then it attempts a better fit.</li>
</ul>
<p>In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match.</p>
<p>The match object has an attribute <tt class="docutils literal">fuzzy_counts</tt> which gives the total number of substitutions, insertions and deletions.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="comment single"># A 'raw' fuzzy match:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?:cats|cat){e<=1}"</span><span class="punctuation">,</span> <span class="literal string double">"cat"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">fuzzy_counts</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># 0 substitutions, 0 insertions, 1 deletion.</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># A better match might be possible if the ENHANCEMATCH flag used:</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">fullmatch</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"(?e)(?:cats|cat){e<=1}"</span><span class="punctuation">,</span> <span class="literal string double">"cat"</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">fuzzy_counts</span><span class="whitespace">
</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">0</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="comment single"># 0 substitutions, 0 insertions, 0 deletions.</span>
</pre>
<p>The match object also has an attribute <tt class="docutils literal">fuzzy_changes</tt> which gives a tuple of the positions of the substitutions, insertions and deletions.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">m</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">search</span><span class="punctuation">(</span><span class="literal string single">'(fuu){i<=2,d<=2,e<=5}'</span><span class="punctuation">,</span> <span class="literal string single">'anaconda foo bar'</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="whitespace">
</span><span class="operator"><</span><span class="name">regex</span><span class="operator">.</span><span class="name">Match</span> <span class="name builtin">object</span><span class="punctuation">;</span> <span class="name">span</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">7</span><span class="punctuation">,</span> <span class="literal number integer">10</span><span class="punctuation">),</span> <span class="name">match</span><span class="operator">=</span><span class="literal string single">'a f'</span><span class="punctuation">,</span> <span class="name">fuzzy_counts</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">)</span><span class="operator">></span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">m</span><span class="operator">.</span><span class="name">fuzzy_changes</span><span class="whitespace">
</span><span class="punctuation">([],</span> <span class="punctuation">[</span><span class="literal number integer">7</span><span class="punctuation">,</span> <span class="literal number integer">8</span><span class="punctuation">],</span> <span class="punctuation">[</span><span class="literal number integer">10</span><span class="punctuation">,</span> <span class="literal number integer">11</span><span class="punctuation">])</span>
</pre>
<p>What this means is that if the matched part of the string had been:</p>
<pre class="code python literal-block">
<span class="literal string single">'anacondfuuoo bar'</span>
</pre>
<p>it would've been an exact match.</p>
<p>However, there were insertions at positions 7 and 8:</p>
<pre class="code python literal-block">
<span class="literal string single">'anaconda fuuoo bar'</span><span class="whitespace">
</span> <span class="operator">^^</span>
</pre>
<p>and deletions at positions 10 and 11:</p>
<pre class="code python literal-block">
<span class="literal string single">'anaconda f~~oo bar'</span><span class="whitespace">
</span> <span class="operator">^^</span>
</pre>
<p>So the actual string was:</p>
<pre class="code python literal-block">
<span class="literal string single">'anaconda foo bar'</span>
<div class="section" id="named-lists-l-name-hg-issue-11">
<h2>Named lists <tt class="docutils literal">\L<name></tt> (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/11">Hg issue 11</a>)</h2>
<p>There are occasions where you may want to include a list (actually, a set) of options in a regex.</p>
<p>One way is to build the pattern like this:</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">p</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"first|second|third|fourth|fifth"</span><span class="punctuation">)</span>
<p>but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, "cats" before "cat".</p>
<p>The new alternative is to use a named list:</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">option_set</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="literal string double">"first"</span><span class="punctuation">,</span> <span class="literal string double">"second"</span><span class="punctuation">,</span> <span class="literal string double">"third"</span><span class="punctuation">,</span> <span class="literal string double">"fourth"</span><span class="punctuation">,</span> <span class="literal string double">"fifth"</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">p</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"\L<options>"</span><span class="punctuation">,</span> <span class="name">options</span><span class="operator">=</span><span class="name">option_set</span><span class="punctuation">)</span>
</pre>
<p>The order of the items is irrelevant, they are treated as a set. The named lists are available as the <tt class="docutils literal">.named_lists</tt> attribute of the pattern object :</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name builtin">print</span><span class="punctuation">(</span><span class="name">p</span><span class="operator">.</span><span class="name">named_lists</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="punctuation">{</span><span class="literal string single">'options'</span><span class="punctuation">:</span> <span class="name builtin">frozenset</span><span class="punctuation">({</span><span class="literal string single">'third'</span><span class="punctuation">,</span> <span class="literal string single">'first'</span><span class="punctuation">,</span> <span class="literal string single">'fifth'</span><span class="punctuation">,</span> <span class="literal string single">'fourth'</span><span class="punctuation">,</span> <span class="literal string single">'second'</span><span class="punctuation">})}</span>
<p>If there are any unused keyword arguments, <tt class="docutils literal">ValueError</tt> will be raised unless you tell it otherwise:</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">option_set</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="literal string double">"first"</span><span class="punctuation">,</span> <span class="literal string double">"second"</span><span class="punctuation">,</span> <span class="literal string double">"third"</span><span class="punctuation">,</span> <span class="literal string double">"fourth"</span><span class="punctuation">,</span> <span class="literal string double">"fifth"</span><span class="punctuation">]</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">p</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"\L<options>"</span><span class="punctuation">,</span> <span class="name">options</span><span class="operator">=</span><span class="name">option_set</span><span class="punctuation">,</span> <span class="name">other_options</span><span class="operator">=</span><span class="punctuation">[])</span><span class="whitespace">
</span><span class="name">Traceback</span> <span class="punctuation">(</span><span class="name">most</span> <span class="name">recent</span> <span class="name">call</span> <span class="name">last</span><span class="punctuation">):</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"<stdin>"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="operator"><</span><span class="name">module</span><span class="operator">></span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">353</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name builtin">compile</span><span class="whitespace">
</span> <span class="keyword">return</span> <span class="name">_compile</span><span class="punctuation">(</span><span class="name">pattern</span><span class="punctuation">,</span> <span class="name">flags</span><span class="punctuation">,</span> <span class="name">ignore_unused</span><span class="punctuation">,</span> <span class="name">kwargs</span><span class="punctuation">,</span> <span class="name">cache_pattern</span><span class="punctuation">)</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">500</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name">_compile</span><span class="whitespace">
</span> <span class="name">complain_unused_args</span><span class="punctuation">()</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">483</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name">complain_unused_args</span><span class="whitespace">
</span> <span class="keyword">raise</span> <span class="name exception">ValueError</span><span class="punctuation">(</span><span class="literal string single">'unused keyword argument </span><span class="literal string interpol">{!a}</span><span class="literal string single">'</span><span class="operator">.</span><span class="name">format</span><span class="punctuation">(</span><span class="name">any_one</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="name exception">ValueError</span><span class="punctuation">:</span> <span class="name">unused</span> <span class="name">keyword</span> <span class="name">argument</span> <span class="literal string single">'other_options'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">p</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"\L<options>"</span><span class="punctuation">,</span> <span class="name">options</span><span class="operator">=</span><span class="name">option_set</span><span class="punctuation">,</span> <span class="name">other_options</span><span class="operator">=</span><span class="punctuation">[],</span> <span class="name">ignore_unused</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">p</span> <span class="operator">=</span> <span class="name">regex</span><span class="operator">.</span><span class="name">compile</span><span class="punctuation">(</span><span class="literal string affix">r</span><span class="literal string double">"\L<options>"</span><span class="punctuation">,</span> <span class="name">options</span><span class="operator">=</span><span class="name">option_set</span><span class="punctuation">,</span> <span class="name">other_options</span><span class="operator">=</span><span class="punctuation">[],</span> <span class="name">ignore_unused</span><span class="operator">=</span><span class="keyword constant">False</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="name">Traceback</span> <span class="punctuation">(</span><span class="name">most</span> <span class="name">recent</span> <span class="name">call</span> <span class="name">last</span><span class="punctuation">):</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"<stdin>"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="operator"><</span><span class="name">module</span><span class="operator">></span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">353</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name builtin">compile</span><span class="whitespace">
</span> <span class="keyword">return</span> <span class="name">_compile</span><span class="punctuation">(</span><span class="name">pattern</span><span class="punctuation">,</span> <span class="name">flags</span><span class="punctuation">,</span> <span class="name">ignore_unused</span><span class="punctuation">,</span> <span class="name">kwargs</span><span class="punctuation">,</span> <span class="name">cache_pattern</span><span class="punctuation">)</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">500</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name">_compile</span><span class="whitespace">
</span> <span class="name">complain_unused_args</span><span class="punctuation">()</span><span class="whitespace">
</span> <span class="name">File</span> <span class="literal string double">"C:\Python310\lib\site-packages</span><span class="literal string escape">\r</span><span class="literal string double">egex</span><span class="literal string escape">\r</span><span class="literal string double">egex.py"</span><span class="punctuation">,</span> <span class="name">line</span> <span class="literal number integer">483</span><span class="punctuation">,</span> <span class="operator word">in</span> <span class="name">complain_unused_args</span><span class="whitespace">
</span> <span class="keyword">raise</span> <span class="name exception">ValueError</span><span class="punctuation">(</span><span class="literal string single">'unused keyword argument </span><span class="literal string interpol">{!a}</span><span class="literal string single">'</span><span class="operator">.</span><span class="name">format</span><span class="punctuation">(</span><span class="name">any_one</span><span class="punctuation">))</span><span class="whitespace">
</span><span class="name exception">ValueError</span><span class="punctuation">:</span> <span class="name">unused</span> <span class="name">keyword</span> <span class="name">argument</span> <span class="literal string single">'other_options'</span><span class="whitespace">
</span><span class="operator">>>></span>
</pre>
</div>
<div class="section" id="start-and-end-of-word">
<h2>Start and end of word</h2>
<p><tt class="docutils literal">\m</tt> matches at the start of a word.</p>
<p><tt class="docutils literal">\M</tt> matches at the end of a word.</p>
<p>Compare with <tt class="docutils literal">\b</tt>, which matches at the start or end of a word.</p>
</div>
<div class="section" id="unicode-line-separators">
<h2>Unicode line separators</h2>
<p>Normally the only line separator is <tt class="docutils literal">\n</tt> (<tt class="docutils literal">\x0A</tt>), but if the <tt class="docutils literal">WORD</tt> flag is turned on then the line separators are <tt class="docutils literal">\x0D\x0A</tt>, <tt class="docutils literal">\x0A</tt>, <tt class="docutils literal">\x0B</tt>, <tt class="docutils literal">\x0C</tt> and <tt class="docutils literal">\x0D</tt>, plus <tt class="docutils literal">\x85</tt>, <tt class="docutils literal">\u2028</tt> and <tt class="docutils literal">\u2029</tt> when working with Unicode.</p>
<p>This affects the regex dot <tt class="docutils literal">"."</tt>, which, with the <tt class="docutils literal">DOTALL</tt> flag turned off, matches any character except a line separator. It also affects the line anchors <tt class="docutils literal">^</tt> and <tt class="docutils literal">$</tt> (in multiline mode).</p>
</div>
<div class="section" id="set-operators">
<h2>Set operators</h2>
<p><strong>Version 1 behaviour only</strong></p>
<p>Set operators have been added, and a set <tt class="docutils literal"><span class="pre">[...]</span></tt> can include nested sets.</p>
<p>The operators, in order of increasing precedence, are:</p>
<ul class="simple">
<li><tt class="docutils literal">||</tt> for union ("x||y" means "x or y")</li>
<li><tt class="docutils literal">~~</tt> (double tilde) for symmetric difference ("x~~y" means "x or y, but not both")</li>
<li><tt class="docutils literal">&&</tt> for intersection ("x&&y" means "x and y")</li>
<li><tt class="docutils literal"><span class="pre">--</span></tt> (double dash) for difference ("x--y" means "x but not y")</li>
</ul>
<p>Implicit union, ie, simple juxtaposition like in <tt class="docutils literal">[ab]</tt>, has the highest precedence. Thus, <tt class="docutils literal"><span class="pre">[ab&&cd]</span></tt> is the same as <tt class="docutils literal"><span class="pre">[[a||b]&&[c||d]]</span></tt>.</p>
<p>Examples:</p>
<ul class="simple">
<li><tt class="docutils literal">[ab]</tt> # Set containing 'a' and 'b'</li>
<li><tt class="docutils literal"><span class="pre">[a-z]</span></tt> # Set containing 'a' .. 'z'</li>
<li><tt class="docutils literal"><span class="pre">[[a-z]--[qw]]</span></tt> # Set containing 'a' .. 'z', but not 'q' or 'w'</li>
<li><tt class="docutils literal"><span class="pre">[a-z--qw]</span></tt> # Same as above</li>
<li><tt class="docutils literal"><span class="pre">[\p{L}--QW]</span></tt> # Set containing all letters except 'Q' and 'W'</li>
<li><tt class="docutils literal"><span class="pre">[\p{N}--[0-9]]</span></tt> # Set containing all numbers except '0' .. '9'</li>
<li><tt class="docutils literal"><span class="pre">[\p{ASCII}&&\p{Letter}]</span></tt> # Set containing all characters which are ASCII and letter</li>
</ul>
</div>
<div class="section" id="regex-escape-issue-2650">
<h2>regex.escape (<a class="reference external" href="https://bugs.python.org/issue2650">issue #2650</a>)</h2>
<p>regex.escape has an additional keyword parameter <tt class="docutils literal">special_only</tt>. When True, only 'special' regex characters, such as '?', are escaped.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">escape</span><span class="punctuation">(</span><span class="literal string double">"foo!?"</span><span class="punctuation">,</span> <span class="name">special_only</span><span class="operator">=</span><span class="keyword constant">False</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo</span><span class="literal string escape">\\</span><span class="literal string single">!</span><span class="literal string escape">\\</span><span class="literal string single">?'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">escape</span><span class="punctuation">(</span><span class="literal string double">"foo!?"</span><span class="punctuation">,</span> <span class="name">special_only</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo!</span><span class="literal string escape">\\</span><span class="literal string single">?'</span>
</div>
<div class="section" id="regex-escape-hg-issue-249">
<h2>regex.escape (<a class="reference external" href="https://github.com/mrabarnett/mrab-regex/issues/249">Hg issue 249</a>)</h2>
<p>regex.escape has an additional keyword parameter <tt class="docutils literal">literal_spaces</tt>. When True, spaces are not escaped.</p>
<pre class="code python literal-block">
<span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">escape</span><span class="punctuation">(</span><span class="literal string double">"foo bar!?"</span><span class="punctuation">,</span> <span class="name">literal_spaces</span><span class="operator">=</span><span class="keyword constant">False</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo</span><span class="literal string escape">\\</span><span class="literal string single"> bar!</span><span class="literal string escape">\\</span><span class="literal string single">?'</span><span class="whitespace">
</span><span class="operator">>>></span> <span class="name">regex</span><span class="operator">.</span><span class="name">escape</span><span class="punctuation">(</span><span class="literal string double">"foo bar!?"</span><span class="punctuation">,</span> <span class="name">literal_spaces</span><span class="operator">=</span><span class="keyword constant">True</span><span class="punctuation">)</span><span class="whitespace">
</span><span class="literal string single">'foo bar!</span><span class="literal string escape">\\</span><span class="literal string single">?'</span>
</div>
<div class="section" id="repeated-captures-issue-7132">
<h2>Repeated captures (<a class="reference external" href="https://bugs.python.org/issue7132">issue #7132</a>)</h2>
<p>A match object has additional methods which return information on all the successful matches of a repeated group. These methods are:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">matchobject.captures([group1,</span> <span class="pre">...])</span></tt><ul>
<li>Returns a list of the strings matched in a group or groups. Compare with <tt class="docutils literal"><span class="pre">matchobject.group([group1,</span> <span class="pre">...])</span></tt>.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">matchobject.starts([group])</span></tt><ul>
<li>Returns a list of the start positions. Compare with <tt class="docutils literal"><span class="pre">matchobject.start([group])</span></tt>.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">matchobject.ends([group])</span></tt><ul>