python 正则 re模块(详细版)
<h1>正则表达式</h1><p><strong>什么是正则表达式？</strong></p>
<p> 正则表达式是对字符串（包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”））操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式，该模式描述在搜索文本时要匹配的一个或多个字符串。</p>
<p><strong>正则表达式可以干什么?</strong></p>
<ul>
<li>快速高效的查找与分析字符串</li>
<li>进行有规律查找比对字符串，也叫：模式匹配</li>
<li>具有查找、比对、匹配、替换、插入、添加、删除等能力。</li>
</ul>
<p> 字符串是编程时涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。比如我们编写爬虫收集数据，首先都得到网页源码，但是我们要如何提取有效数据呢，这时候我们就需要使用正则表达式来进行匹配了</p>
<hr>
<p> </p>
<h1>re模块</h1>
<p>正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。</p>
<p>由于Python的字符串本身也用<code>\</code>转义，所以要特别注意：</p>
<div class="cnblogs_code">
<pre>s = 'ABC\\-001' # Python的字符串
# 对应的正则表达式字符串变成：
# 'ABC\-001'</pre>
</div>
<p>因此建议使用Python的<code>r</code>前缀，就不用考虑转义的问题了：</p>
<div class="cnblogs_code">
<pre>s = r'ABC\-001' # Python的字符串
# 对应的正则表达式字符串不变：
# 'ABC\-001'</pre>
</div>
<hr>
<p> </p>
<h2>re模块符号大全</h2>
<h3>正则表达式模式</h3>
<p>模式字符串使用特殊的语法来表示一个正则表达式：</p>
<p>字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。</p>
<p>多数字母和数字前加一个反斜杠时会拥有不同的含义。</p>
<p>标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。</p>
<p>反斜杠本身需要使用反斜杠转义。</p>
<p>由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 <span class="marked">r'\t'，等价于 <span class="marked">\\t )匹配相应的特殊字符。</span></span></p>
<p>下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。</p>
<table class="reference">
<tbody>
<tr><th>模式</th><th>描述</th></tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">^</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配字符串的开头</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">$</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配字符串的末尾。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">.</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">[...]</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">用来表示一组字符,单独列出： 匹配 'a'，'m'或'k'</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">[^...]</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re*</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配0个或多个的表达式。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re+</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配1个或多个的表达式。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re?</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re{ n}</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re{ n,}</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">re{ n, m}</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">a|b</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配a或b</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">(re)</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配括号内的表达式，也表示一个组</span></td>
</tr>
<tr>
<td>(?imx)</td>
<td>正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。</td>
</tr>
<tr>
<td>(?-imx)</td>
<td>正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。</td>
</tr>
<tr>
<td>(?: re)</td>
<td>类似 (...), 但是不表示一个组</td>
</tr>
<tr>
<td>(?imx: re)</td>
<td>在括号中使用i, m, 或 x 可选标志</td>
</tr>
<tr>
<td>(?-imx: re)</td>
<td>在括号中不使用i, m, 或 x 可选标志</td>
</tr>
<tr>
<td>(?#...)</td>
<td>注释.</td>
</tr>
<tr>
<td>(?= re)</td>
<td>前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。</td>
</tr>
<tr>
<td>(?! re)</td>
<td>前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。</td>
</tr>
<tr>
<td>(?> re)</td>
<td>匹配的独立模式，省去回溯。</td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\w</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配数字字母下划线</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\W</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配非数字字母下划线</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\s</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配任意空白字符，等价于 [\t\n\r\f]。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\S</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配任意非空字符</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\d</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配任意数字，等价于 。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\D</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配任意非数字</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\A</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配字符串开始</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\Z</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\z</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配字符串结束</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\G</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配最后匹配完成的位置。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\b</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\B</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。</span></td>
</tr>
<tr>
<td><span style="color: rgba(255, 0, 0, 1)">\n, \t, 等。</span></td>
<td><span style="color: rgba(255, 0, 0, 1)">匹配一个换行符。匹配一个制表符, 等</span></td>
</tr>
<tr>
<td>\1...\9</td>
<td>匹配第n个分组的内容。</td>
</tr>
<tr>
<td>\10</td>
<td>匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。</td>
</tr>
</tbody>
</table>
<p><span style="color: rgba(255, 0, 0, 1)"><span style="color: rgba(0, 0, 0, 1)"><br></span>注意</span>：表中re指的是表达式而不是字面的re这两个字母</p>
<h3 id="flags">正则表达式修饰符 - 可选标志</h3>
<p>正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：</p>
<table class="reference">
<tbody>
<tr><th>修饰符</th><th>描述</th></tr>
<tr>
<td>re.I</td>
<td>使匹配对大小写不敏感</td>
</tr>
<tr>
<td>re.L</td>
<td>做本地化识别（locale-aware）匹配</td>
</tr>
<tr>
<td>re.M</td>
<td>多行匹配，影响 ^ 和 $</td>
</tr>
<tr>
<td>re.S</td>
<td>使 . 匹配包括换行在内的所有字符</td>
</tr>
<tr>
<td>re.U</td>
<td>根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.</td>
</tr>
<tr>
<td>re.X</td>
<td>该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。</td>
</tr>
</tbody>
</table>
<h3>正则表达式对象</h3>
<p><strong>re.RegexObject</strong></p>
<p>re.compile() 返回 RegexObject 对象。</p>
<p><strong>re.MatchObject</strong></p>
<p>group() 返回被 RE 匹配的字符串。</p>
<ul>
<li><span class="marked">start() 返回匹配开始的位置</span></li>
<li><span class="marked">end() 返回匹配结束的位置</span></li>
<li><span class="marked">span() 返回一个元组包含匹配 (开始,结束) 的位置</span></li>
</ul>
<hr>
<h2> </h2>
<h2>准备知识</h2>
<p>我们先来看看廖雪峰老师讲解的正则表达式：</p>
<p>正则表达式是用字符串表示的，所以，我们要首先了解如何用字符来描述字符。</p>
<p>在正则表达式中，如果直接给出字符，就是精确匹配。</p>
<p>使用特殊符号表示字符：用<code>\d</code>可以匹配一个数字，<code>\w</code>可以匹配一个字母或数字，例如：</p>
<ul>
<li>
<p><code>'00\d'</code>可以匹配<code>'007'</code>，但无法匹配<code>'00A'</code>；</p>
</li>
<li>
<p><code>'\d\d\d'</code>可以匹配<code>'010'</code>；</p>
</li>
<li>
<p><code>'\w\w\d'</code>可以匹配<code>'py3'。</code></p>
</li>
</ul>
<p><code>'.'</code>可以匹配任意字符，所以：</p>
<ul>
<li><code>'py.'</code>可以匹配<code>'pyc'</code>、<code>'py3'</code>、<code>'py!'</code>等等。</li>
</ul>
<p>要匹配变长的字符，在正则表达式中，用<code>*</code>表示任意个字符（包括0个），用<code>+</code>表示至少一个字符，用<code>?</code>表示0个或1个字符，用<code>{n}</code>表示n个字符，用<code>{n,m}</code>表示n-m个字符。</p>
<p>来看一个复杂的例子：<code>\d{3}\s+\d{3,8}</code>。</p>
<p>我们来从左到右解读一下：</p>
<ol>
<li>
<p><code>\d{3}</code>表示匹配3个数字，例如<code>'010'</code>；</p>
</li>
<li>
<p><code>\s</code>可以匹配一个空格（也包括Tab等空白符），所以<code>\s+</code>表示至少有一个空格，例如匹配<code>' '</code>，<code>' '</code>等；</p>
</li>
<li>
<p><code>\d{3,8}</code>表示3-8个数字，例如<code>'1234567'</code>。</p>
</li>
</ol>
<p>综合起来，上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。</p>
<p>如果要匹配<code>'010-12345'</code>这样的号码呢？由于<code>'-'</code>是特殊字符，在正则表达式中，要用<code>'\'</code>转义，所以，上面的正则是<code>\d{3}\-\d{3,8}</code>。</p>
<p>但是，仍然无法匹配<code>'010 - 12345'</code>，因为带有空格。所以我们需要更复杂的匹配方式。</p>
<h3>进阶</h3>
<p>要做更精确地匹配，可以用<code>[]</code>表示范围，比如：</p>
<ul>
<li>
<p><code></code>可以匹配一个数字、字母或者下划线；</p>
</li>
<li>
<p><code>+</code>可以匹配至少由一个数字、字母或者下划线组成的字符串，比如<code>'a100'</code>，<code>'0_Z'</code>，<code>'Py3000'</code>等等；</p>
</li>
<li>
<p><code>*</code>可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量；</p>
</li>
<li>
<p><code>{0, 19}</code>更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。</p>
</li>
</ul>
<p><code>A|B</code>可以匹配A或B，所以<code>(P|p)ython</code>可以匹配<code>'Python'</code>或者<code>'python'</code>。</p>
<p><code>^</code>表示行的开头，<code>^\d</code>表示必须以数字开头。</p>
<p><code>$</code>表示行的结束，<code>\d$</code>表示必须以数字结束。</p>
<p><code>py</code>也可以匹配<code>'python'</code>，但是加上<code>^py$</code>就变成了整行匹配，就只能匹配<code>'py'</code>了。</p>
<hr>
<h1>re模常用方法</h1>
<p> </p>
<h2>re.match()</h2>
<p>re.match 尝试从<span style="color: rgba(255, 0, 0, 1)">字符串的起始位置</span>匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。</p>
<p><strong>函数语法</strong>：</p>
<div class="cnblogs_code">
<pre>re.match(pattern, string, flags=0)</pre>
</div>
<p>函数参数说明：</p>
<table class="reference">
<tbody>
<tr><th>参数</th><th>描述</th></tr>
<tr>
<td>pattern</td>
<td>匹配的正则表达式</td>
</tr>
<tr>
<td>string</td>
<td>要匹配的字符串。</td>
</tr>
<tr>
<td>flags</td>
<td>标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格</td>
</tr>
</tbody>
</table>
<p>匹配成功re.match方法返回一个匹配的对象，否则返回None。</p>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(re.match(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www</span><span style="color: rgba(128, 0, 0, 1)">'</span>,<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www.baidu.com</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">).span())
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(re.match(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">baidu</span><span style="color: rgba(128, 0, 0, 1)">'</span>,<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www.baidu.com</span><span style="color: rgba(128, 0, 0, 1)">'</span>))</pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>(0, 3<span style="color: rgba(0, 0, 0, 1)">)
None</span></pre>
</div>
<p>第一个匹配成功，第二个则失败</p>
<hr>
<h2>re.search()</h2>
<p>re.search 扫描<span style="color: rgba(255, 0, 0, 1)">整个字符串</span>并返回第一个成功的匹配。</p>
<p>函数语法：</p>
<div class="cnblogs_code">
<pre>re.search(pattern, string, flags=0)</pre>
</div>
<p> </p>
<p>函数参数说明：</p>
<table class="reference">
<tbody>
<tr><th>参数</th><th>描述</th></tr>
<tr>
<td>pattern</td>
<td>匹配的正则表达式</td>
</tr>
<tr>
<td>string</td>
<td>要匹配的字符串。</td>
</tr>
<tr>
<td>flags</td>
<td>标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格<br></td>
</tr>
</tbody>
</table>
<p>匹配成功re.search方法返回一个匹配的对象，否则返回None。</p>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(re.search(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www</span><span style="color: rgba(128, 0, 0, 1)">'</span>,<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www.baidu.com</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">))
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(re.search(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">baidu</span><span style="color: rgba(128, 0, 0, 1)">'</span>,<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www.baidu.com</span><span style="color: rgba(128, 0, 0, 1)">'</span>))</pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre><_sre.SRE_Match object; span=(0, 3), match=<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">www</span><span style="color: rgba(128, 0, 0, 1)">'</span>>
<_sre.SRE_Match object; span=(4, 9), match=<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">baidu</span><span style="color: rgba(128, 0, 0, 1)">'</span>></pre>
</div>
<hr>
<h2>compile 函数</h2>
<p>compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，re函数使用。</p>
<p>提前编译可减少多次正则匹配的运行时间</p>
<p>语法格式为：</p>
<div class="cnblogs_code">
<pre>re.compile(pattern[, flags])</pre>
</div>
<p>参数：</p>
<ul>
<li>pattern : 一个字符串形式的正则表达式</li>
<li>flags 可选，表示匹配模式</li>
</ul>
<hr>
<h2>re.findall()</h2>
<p>在字符串中找到正则表达式所匹配的所有子串，并返回一个<span style="color: rgba(255, 0, 0, 1)">列表</span>，如果没有找到匹配的，则返回空列表。</p>
<p><strong>注意：</strong> match 和 search 是匹配一次 findall 匹配所有。</p>
<h3>用法1</h3>
<p>直接使用的语法格式为：</p>
<div class="cnblogs_code">
<pre>re.findall(pattern, string, flags)</pre>
</div>
<p>参数：</p>
<ul>
<li>pattern 正则表达式</li>
<li>string 待匹配的字符串</li>
<li>flags re的一些flag，可不写</li>
</ul>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">print</span>(re.findall(pattern=<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">\d+</span><span style="color: rgba(128, 0, 0, 1)">'</span>, string=<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">abafa 124ddwa56</span><span style="color: rgba(128, 0, 0, 1)">'</span>))</pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>[<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">124</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">56</span><span style="color: rgba(128, 0, 0, 1)">'</span>]</pre>
</div>
<h3>用法2</h3>
<p>compile后使用findall的语法格式为：</p>
<div class="cnblogs_code">
<pre>re.findall(string, pos, endpos)</pre>
</div>
<p>参数：</p>
<ul>
<li><span class="marked">string 待匹配的字符串。</span></li>
<li><span class="marked">pos 可选参数，指定字符串的起始位置，默认为 0。</span></li>
<li><span class="marked">endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。</span></li>
</ul>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
mat</span>=re.compile(r<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">\d+</span><span style="color: rgba(128, 0, 0, 1)">'</span>)<span style="color: rgba(0, 128, 0, 1)">#</span><span style="color: rgba(0, 128, 0, 1)">匹配数字</span>
<span style="color: rgba(0, 0, 255, 1)">print</span>(mat.findall(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">abafa 124ddwa56</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">))
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(mat.findall(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">abafa 124ddwa56</span><span style="color: rgba(128, 0, 0, 1)">'</span>,0,7))<span style="color: rgba(0, 128, 0, 1)">#</span><span style="color: rgba(0, 128, 0, 1)">匹配从0位开始，到7位结束</span></pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>[<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">124</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">56</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">]
[</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">1</span><span style="color: rgba(128, 0, 0, 1)">'</span>]</pre>
</div>
<h2>re.finditer</h2>
<p>和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个<span style="color: rgba(255, 0, 0, 1)">迭代器</span>返回。</p>
<div class="cnblogs_code">
<pre>re.finditer(pattern, string, flags=0)</pre>
</div>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
it </span>= re.finditer(r<span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(128, 0, 0, 1)">\d+</span><span style="color: rgba(128, 0, 0, 1)">"</span>, <span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(128, 0, 0, 1)">12a32bc43jf3</span><span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(0, 0, 0, 1)">)
</span><span style="color: rgba(0, 0, 255, 1)">for</span> match <span style="color: rgba(0, 0, 255, 1)">in</span><span style="color: rgba(0, 0, 0, 1)"> it:
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(match.group())</pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>12
32
43
3</pre>
</div>
<hr>
<h2> </h2>
<h2>re.split</h2>
<p>split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：</p>
<div class="cnblogs_code">
<pre>re.split(pattern, string[, maxsplit=0, flags=0])</pre>
</div>
<p>参数：</p>
<table class="reference">
<tbody>
<tr><th>参数</th><th>描述</th></tr>
<tr>
<td>pattern</td>
<td>匹配的正则表达式</td>
</tr>
<tr>
<td>string</td>
<td>要匹配的字符串。</td>
</tr>
<tr>
<td>maxsplit</td>
<td>分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。</td>
</tr>
<tr>
<td>flags</td>
<td>标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格<br></td>
</tr>
</tbody>
</table>
<p>实例：</p>
<p>用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：</p>
<div class="cnblogs_code">
<pre>>>> 'a b c'.split(' ')
['a', 'b', '', '', 'c']</pre>
</div>
<p>发现无法识别连续的空格，用正则表达式试试：</p>
<div class="cnblogs_code">
<pre>>>> re.split(r'\s+', 'a b c')
['a', 'b', 'c']</pre>
</div>
<p>无论多少个空格都可以正常分割。加入<code>,</code>试试：</p>
<div class="cnblogs_code">
<pre>>>> re.split(r'[\s\,]+', 'a,b, cd')
['a', 'b', 'c', 'd']</pre>
</div>
<p>再加入<code>;</code>试试：</p>
<div class="cnblogs_code">
<pre>>>> re.split(r'[\s\,\;]+', 'a,b;; cd')
['a', 'b', 'c', 'd']</pre>
</div>
<hr>
<h2> </h2>
<h2>groups()</h2>
<p>我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。</p>
<table class="reference">
<tbody>
<tr><th>匹配对象方法</th><th>描述</th></tr>
<tr>
<td>group(num=0)</td>
<td>匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。</td>
</tr>
<tr>
<td>groups()</td>
<td>返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。</td>
</tr>
</tbody>
</table>
<p>实例：</p>
<div class="cnblogs_code">
<pre>import<span> re
m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345'<span>)
print<span>(m.group(0))
print(m.group(1<span>))
print(m.group(2<span>))
print(m.groups())</span></span></span></span></span></pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>010-12345
010
12345<span>
('010', '12345')</span></pre>
</div>
<hr>
<h2>re.sub</h2>
<p>Python 的re模块提供了re.sub用于替换字符串中的匹配项。</p>
<p>语法：</p>
<div class="cnblogs_code">
<pre>re.sub(pattern, repl, string, count=0, flags=0)</pre>
</div>
<p>参数：</p>
<ul>
<li>pattern : 正则中的模式字符串。</li>
<li>repl : 替换的字符串，也可为一个函数。</li>
<li>string : 要被查找替换的原始字符串。</li>
<li>count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。</li>
<li>flags : 编译时用的匹配模式，数字形式。</li>
</ul>
<p>前三个为必选参数，后两个为可选参数。</p>
<p>实例：</p>
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
phone </span>= <span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(128, 0, 0, 1)">2004-959-559 # 这是一个电话号码</span><span style="color: rgba(128, 0, 0, 1)">"</span>
<span style="color: rgba(0, 128, 0, 1)">#</span><span style="color: rgba(0, 128, 0, 1)"> 删除注释</span>
num = re.sub(r<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">#.*$</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">""</span><span style="color: rgba(0, 0, 0, 1)">, phone)
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(<span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(128, 0, 0, 1)">电话号码 : </span><span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(0, 0, 0, 1)">, num)
</span><span style="color: rgba(0, 128, 0, 1)">#</span><span style="color: rgba(0, 128, 0, 1)"> 移除非数字的内容</span>
num = re.sub(r<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">\D</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">""</span><span style="color: rgba(0, 0, 0, 1)">, phone)
</span><span style="color: rgba(0, 0, 255, 1)">print</span>(<span style="color: rgba(128, 0, 0, 1)">"</span><span style="color: rgba(128, 0, 0, 1)">电话号码 : </span><span style="color: rgba(128, 0, 0, 1)">"</span>, num)</pre>
</div>
<h3>repl 参数可以是一个函数</h3>
<p>以下实例中将字符串中的匹配的数字乘于 2：</p>
<div class="example">
<p class="example">实例：</p>
<div class="example_code">
<div class="hl-main">
<div class="cnblogs_code">
<pre><span style="color: rgba(0, 0, 255, 1)">import</span><span style="color: rgba(0, 0, 0, 1)"> re
</span><span style="color: rgba(0, 128, 0, 1)">#</span><span style="color: rgba(0, 128, 0, 1)"> 将匹配的数字乘于 2</span>
<span style="color: rgba(0, 0, 255, 1)">def</span><span style="color: rgba(0, 0, 0, 1)"> double(matched):
value </span>= int(matched.group(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">value</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">))
</span><span style="color: rgba(0, 0, 255, 1)">return</span> str(value * 2<span style="color: rgba(0, 0, 0, 1)">)
s </span>= <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">A23G4HFD567</span><span style="color: rgba(128, 0, 0, 1)">'</span>
<span style="color: rgba(0, 0, 255, 1)">print</span>(re.sub(<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">(?P<value>\d+)</span><span style="color: rgba(128, 0, 0, 1)">'</span>, double, s))</pre>
</div>
<p>输出：</p>
<div class="cnblogs_code">
<pre>A46G8HFD1134</pre>
</div>
</div>
</div>
</div>
<hr>
<h2> </h2>
<h2>贪婪匹配</h2>
<p>需要<span style="color: rgba(255, 0, 0, 1)">特别指出</span>的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的<code>0</code>：</p>
<div class="cnblogs_code">
<pre>>>> re.match(r<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">^(\d+)(0*)$</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">102300</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">).groups()
(</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">102300</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">''</span>)</pre>
</div>
<p>由于<code>\d+</code>采用贪婪匹配，直接把后面的<code>0</code>全部匹配了，结果<code>0*</code>只能匹配空字符串了。</p>
<p>必须让<code>\d+</code>采用非贪婪匹配（也就是尽可能少匹配），才能把后面的<code>0</code>匹配出来，加个<code>?</code>就可以让<code>\d+</code>采用非贪婪匹配：</p>
<div class="cnblogs_code">
<pre>>>> re.match(r<span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">^(\d+?)(0*)$</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">102300</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(0, 0, 0, 1)">).groups()
(</span><span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">1023</span><span style="color: rgba(128, 0, 0, 1)">'</span>, <span style="color: rgba(128, 0, 0, 1)">'</span><span style="color: rgba(128, 0, 0, 1)">00</span><span style="color: rgba(128, 0, 0, 1)">'</span>)</pre>
</div>
<hr>
<h2>正则表达式实例</h2>
<h4>字符匹配</h4>
<table class="reference">
<tbody>
<tr><th>实例</th><th>描述</th></tr>
<tr>
<td>python</td>
<td>匹配 "python".</td>
</tr>
</tbody>
</table>
<h4>字符类</h4>
<table class="reference">
<tbody>
<tr><th>实例</th><th>描述</th></tr>
<tr>
<td>ython</td>
<td>匹配 "Python" 或 "python"</td>
</tr>
<tr>
<td>rub</td>
<td>匹配 "ruby" 或 "rube"</td>
</tr>
<tr>
<td></td>
<td>匹配中括号内的任意一个字母</td>
</tr>
<tr>
<td></td>
<td>匹配任何数字。类似于 </td>
</tr>
<tr>
<td></td>
<td>匹配任何小写字母</td>
</tr>
<tr>
<td></td>
<td>匹配任何大写字母</td>
</tr>
<tr>
<td></td>
<td>匹配任何字母及数字</td>
</tr>
<tr>
<td>[^aeiou]</td>
<td>除了aeiou字母以外的所有字符</td>
</tr>
<tr>
<td>[^0-9]</td>
<td>匹配除了数字外的字符</td>
</tr>
</tbody>
</table>
<h4>特殊字符类</h4>
<table class="reference">
<tbody>
<tr><th>实例</th><th>描述</th></tr>
<tr>
<td>.</td>
<td>匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。</td>
</tr>
<tr>
<td>\d</td>
<td>匹配一个数字字符。等价于 。</td>
</tr>
<tr>
<td>\D</td>
<td>匹配一个非数字字符。等价于 [^0-9]。</td>
</tr>
<tr>
<td>\s</td>
<td>匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。</td>
</tr>
<tr>
<td>\S</td>
<td>匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</td>
</tr>
<tr>
<td>\w</td>
<td>匹配包括下划线的任何单词字符。等价于''。</td>
</tr>
<tr>
<td>\W</td>
<td>匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。</td>
</tr>
</tbody>
</table>
<p> </p>
</div>
<div id="MySignature" role="contentinfo">
<strong>喜欢的觉得有用的就点个赞吧，点波关注不迷路呦</strong><br><br>
来源：https://www.cnblogs.com/CYHISTW/p/11363209.html
頁:
[1]