Python 3.X | re模块，Regular Expression（正则表达式）

迷南。 2022-05-04 09:26 201阅读 0赞

Python 3.6.3、Windows 10  
  
“我知道 可以使用正则表达式来解决这个问题”。于是，现在“我”就有了两个问题需要解答了：

1.  正则表达式本身就是一个难题，但非常有用。
2.  原问题。

一、理论篇  
1、起源  
![在这里插入图片描述][70]  
正则表达式 起源于上图4位美国大佬：

1.  1943年，Warren McCulloch和Walter Pitts研究出一种用数学方法来描述神经网络的新方法；
2.  1956年，Stephen Cole Kleene基于前两位大佬的基础上发表《神经网事件的表示法》论文，文中引入正则表达式的概念，用于描述作者称为“正则集的代数”的表达式，因而采用正则表达式这个术语；
3.  Ken Thompson将成果应用于计算搜索算法的一些早期研究，即第一次将正则表达式应用到Unix QED编辑器中。

随之，由于正则表达式强大的文本处理能力，很快被广泛应用于Perl、PHP、JavaScript、JAVA、Python、Ruby等语言和开发环境中。

2、概念和原理简介

正则表达式（又称 `规则表达式`）是用来描述字符串特定结构（规则）的语言（即 本身就是一种小型的、高度专业化的编程语言），由相关引擎执行。  
在Python中，通过内嵌集成`re`模块，可直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后经由C编写的匹配引擎执行。  
![在这里插入图片描述][70 1]  
正则表达式是一种特殊的字符串模式，用于匹配一组字符串。运用给定的组成规则和字符来匹配表达式。  
![在这里插入图片描述][70 2]  
3、作用

通常被用来检索、替换那些符合某个模式（规则）的文本。

1.  数据验证（测试字符串内的模式）：测试输入的字符串 是否符合一定的规则、是否允许输入等。例如可测试输入的字符串，以查看字符串内是否出现电话号码模式、信用卡号码模式、IP地址模式等；对Email地址合法性、出生年月日等进行验证。
2.  操作文本：使用正则表达式识别文档中的特定文本，完全删除该文本或用其他文本替换掉。
3.  基于模式匹配从字符串中提取子字符串：查找文档内、或输入域内特定的文本。

4、基础语法（规则）

前情提要：

1.  字符串 是编程中涉及到的最多的一种数据结构，对字符串进行操作的需求无处不在。  
    正则表达式的匹配（操作）对象 是字符串，而不是其他类型的内容。
2.  要搜索的模式 和字符串 可以是Unicode字符串（str）或8位字符串（字节）。但是，不可将Unicode字符串与字节模式匹配，反之亦然。即 类型必须相同。
3.  反斜杠 `\` 的困扰：正则表达式使用反斜杠字符`\`作为转义字符。这可能会产生一些冲突，例：需要匹配文本中的字符`\`，那么使用编程语言表示的正则表达式里将需要4个反斜杠`\\\\`：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。解决方案是使用Raw String（原始字符串），它是未经过特殊处理的字符串，如转义序列。如果需要去指定原始字符串，则只需在其前面加 `r` 或 `R` 即可：例中的正则表达式可使用`r"\\"`表示。同样，匹配一个数字的`\\d`可以写成`r"\d"`。`r"Newlines are indicated by \n"`。在正则表达式中，应全程使用原始字符串。否则将会有大量Backwhacking需要处理。
4.  正则表达式可以连接起来形成新的正则表达式。例如`A`、`B`都是正则表达式，则`AB`也是正则表达式。即一个字符串`p`匹配`A`，字符串`q`匹配`B`，则字符串`pq`匹配`AB`。
5.  数量词的贪婪模式与非贪婪模式：Python中数量词默认是贪婪的，总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。例：正则表达式 `ab*`如果用于查找`abbbc`，将找到`abbb`；而如果使用非贪婪的数量词`ab*?`，将找到`a`。
6.  匹配模式：正则表达式提供了一些可用的匹配模式，比如忽略大小写、多行匹配等，这部分内容将在`Pattern`类的工厂方法`re.compile(pattern[, flags])`中一起介绍。

Python 3.X 支持的正则表达式 元字符和语法：

<table> 
 <tbody> 
  <tr> 
   <td><font>语法</font></td> 
   <td><font>说明</font></td> 
   <td><font>表达式实例</font></td> 
   <td><font>完整匹配的字符串</font></td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>字符</font></td> 
  </tr> 
  <tr> 
   <td>字母、数字</td> 
   <td>匹配自身</td> 
   <td>abc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><font><code>.</code></font></td> 
   <td>点号，匹配任意除换行符(\n)外的字符(在DOTALL模式中也能匹配换行符)</td> 
   <td>a.c</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\</code></td> 
   <td>转义字符，使后一个字符改变原来的意思。如果字符串中有字符*需要匹配，可使用\* 或字符集[*]。</td> 
   <td>a\.c<br>a\\c</td> 
   <td>a.c<br>a\c</td> 
  </tr> 
  <tr> 
   <td><code>[...]</code></td> 
   <td>字符集（字符类）。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。第一个字符如果是^，则表示取反，如[^abc]表示不是abc的其他字符，即非abc。所有的特殊字符在字符集中都失去其原有的特殊含义。在字符集中如果要使用]、-或^，可以在前面加上反斜杠，或把]、-放置第一个字符，把^放在非第一个字符。</td> 
   <td>a[bcd]e</td> 
   <td>abe<br>ace<br>ade</td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>预定义字符集（可以写在字符集[...]中）</font></td> 
  </tr> 
  <tr> 
   <td><code>\d</code></td> 
   <td>数字：[0-9]</td> 
   <td>a\dc</td> 
   <td>a1c</td> 
  </tr> 
  <tr> 
   <td><code>\D</code></td> 
   <td>非数字：[^\d]</td> 
   <td>a\Dc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\s</code></td> 
   <td>空白字符：[&lt;空格&gt;\t\r\n\f\v]</td> 
   <td>a\sc</td> 
   <td>a c</td> 
  </tr> 
  <tr> 
   <td><code>\S</code></td> 
   <td>非空白字符：[^\s]</td> 
   <td>a\Sc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\w</code></td> 
   <td>单词字符：[A-Za-z0-9]</td> 
   <td>a\wc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\W</code></td> 
   <td>非单词字符：[^\w]</td> 
   <td>a\Wc</td> 
   <td>a c</td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>数量词（用在字符或(...)之后）</font></td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td>匹配前一个字符0次或无限次</td> 
   <td>abc*</td> 
   <td>ab<br>abccc</td> 
  </tr> 
  <tr> 
   <td><code>+</code></td> 
   <td>匹配前一个字符1次或无限次</td> 
   <td>abc+</td> 
   <td>abc<br>abccc</td> 
  </tr> 
  <tr> 
   <td><code>?</code></td> 
   <td>匹配前一个字符0次或1次</td> 
   <td>abc?</td> 
   <td>ab<br>abc</td> 
  </tr> 
  <tr> 
   <td><code>{m}</code></td> 
   <td>匹配前一个字符m次</td> 
   <td>ab{2}c</td> 
   <td>abbc</td> 
  </tr> 
  <tr> 
   <td><code>{m,n}</code></td> 
   <td>匹配前一个字符m至n次。<br>m和n可以省略：若省略m，则匹配0至n次；若省略n，则匹配m至无限次。</td> 
   <td>ab{1,2}c</td> 
   <td>abc<br>abbc</td> 
  </tr> 
  <tr> 
   <td><code>*?；+?；??；{m,n}?</code></td> 
   <td>使* + ? {m,n}变成非贪婪模式。</td> 
   <td colspan="2">示例将在下文中介绍。</td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>边界匹配（不消耗待匹配字符串中的字符）</font></td> 
  </tr> 
  <tr> 
   <td><code>^</code></td> 
   <td>匹配字符串开头。<br>在多行模式中匹配每一行的开头。</td> 
   <td>^abc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>$</code></td> 
   <td>匹配字符串末尾 或刚好在字符串末尾的新行之前。<br>在多行模式中匹配每一行的末尾。</td> 
   <td>abc$</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\A</code></td> 
   <td>仅匹配字符串开头。</td> 
   <td>\Aabc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\Z</code></td> 
   <td>仅匹配字符串末尾。</td> 
   <td>abc\Z</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td><code>\b</code></td> 
   <td>匹配\w和\W之间</td> 
   <td>a\b!bc</td> 
   <td>a!bc</td> 
  </tr> 
  <tr> 
   <td><code>\B</code></td> 
   <td>[^\b]</td> 
   <td>a\Bbc</td> 
   <td>abc</td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>逻辑、分组</font></td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td>或。匹配 | 左右表达式任意一个，从左到右匹配。<br>它总是先尝试匹配左边的表达式，一旦成功匹配则跳过匹配右边的表达式。<br>如果 | 没有包括在()中，则它的范围是整个正则表达式</td> 
   <td>abc|def</td> 
   <td>abc<br>def</td> 
  </tr> 
  <tr> 
   <td><code>(...)</code></td> 
   <td>被括起来的表达式将作为分组，从表达式左边开始每遇到一个分组的左括号<code>"("</code>，编号就+1。<br>另外， 分组表达式作为一个整体，可以后接数量词。表达式中的 | 仅在该组中有效。</td> 
   <td>(abc){2}<br> a(123|456)c</td> 
   <td>abcabc<br> a456c</td> 
  </tr> 
  <tr> 
   <td><code>(?P&lt;</code><code>name&gt;...)</code></td> 
   <td>分组，除了原有的编号外，再指定一个额外的别名。这和分组差不多（下同），这是命名分组。例：要匹配两个相同的字符，即<code>(\w)\1</code>。其中，<code>\1</code>是对<code>(\w)</code>的引用（即下方的 编号分组），不过这样有个弊端（如分组很多、或有嵌套时），不易分清<code>\n</code>引用的哪个分组。命名分组就很直观明了，例改为：<code>(?P&lt;</code><code>word&gt;\w)(?P=word)</code></td> 
   <td><code>(?P&lt;</code><code>id&gt;abc){2}</code></td> 
   <td>abcabc</td> 
  </tr> 
  <tr> 
   <td><code>\&lt;</code><code>number&gt;</code></td> 
   <td>引用编号为<code>&lt;</code><code>number&gt;</code>的分组 匹配到的字符串。</td> 
   <td>(\d)abc\1</td> 
   <td>1abc1<br>5abc5</td> 
  </tr> 
  <tr> 
   <td><code>(?P=name)</code></td> 
   <td>引用别名为<code>&lt;</code><code>name&gt;</code>的分组 匹配到的字符串。</td> 
   <td><code>(?P&lt;</code><code>id&gt;\d)abc(?P=id)</code></td> 
   <td>1abc1<br>5abc5</td> 
  </tr> 
  <tr> 
   <td colspan="4"><font>特殊构造（不作为分组）</font></td> 
  </tr> 
  <tr> 
   <td><code>(?:...)</code></td> 
   <td>(...)的不分组版本，用于使用“|”或后接数量词</td> 
   <td>(?:abc){2}</td> 
   <td>abcabc</td> 
  </tr> 
  <tr> 
   <td><code>(?aiLmsux)</code></td> 
   <td>aiLmsux的每个字符代表一个匹配模式，只能用在正则表达式的开头，可选多个。匹配模式将在下文中介绍。</td> 
   <td>(?i)abc</td> 
   <td>AbC</td> 
  </tr> 
  <tr> 
   <td><code>(?imsx-imsx:...)</code></td> 
   <td>imsx的每个字符代表一个匹配模式。如：Re.i（忽略）；R.m（多行）；Re.S（. 匹配所有）；Re.X（verbose），用于表达式的一部分。</td> 
   <td colspan="2"><font>Python 3.6 新增</font>。示例将在下文中介绍。</td> 
  </tr> 
  <tr> 
   <td><code>(?#...)</code></td> 
   <td>#后的内容将作为注释被忽略。</td> 
   <td>abc(?#comment)123</td> 
   <td>abc123</td> 
  </tr> 
  <tr> 
   <td><code>(?=...)</code></td> 
   <td>之后的字符串内容需要匹配表达式才能成功匹配。不消耗字符串内容。</td> 
   <td>a(?=\d)</td> 
   <td>后面是数字的a</td> 
  </tr> 
  <tr> 
   <td><code>(?!...)</code></td> 
   <td>之后的字符串内容需要不匹配表达式才能成功匹配。不消耗字符串内容。</td> 
   <td>a(?!\d)</td> 
   <td>后面不是数字的a</td> 
  </tr> 
  <tr> 
   <td><code>(?&lt;=...)</code></td> 
   <td>之前的字符串内容需要匹配表达式才能成功匹配。不消耗字符串内容。</td> 
   <td>(?&lt;=\d)a</td> 
   <td>前面是数字的a</td> 
  </tr> 
  <tr> 
   <td><code>(?&lt;!...)</code></td> 
   <td>之前的字符串内容需要不匹配表达式才能成功匹配。不消耗字符串内容。</td> 
   <td>(?&lt;!\d)a</td> 
   <td>前面不是数字的a</td> 
  </tr> 
  <tr> 
   <td><code>(?(id/name)yes-pattern|no-pattern)</code></td> 
   <td>如果编号为id/别名为name的组匹配到字符串，则需要匹配yes-pattern，否则需要匹配no-pattern。|no-pattern可省略。 </td> 
   <td>(\d)abc(?(1)\d|abc)</td> 
   <td>1abc2<br>abcabc</td> 
  </tr> 
 </tbody> 
</table>

二、Python正则表达式 | 实践篇：`re`模块详解

Python通过 `re`模块实现正则表达式。使用 `re`的一般步骤是先将正则表达式的字符串形式编译为`Pattern`实例；然后使用`Pattern`实例处理文本并获得匹配结果（一个`Match`实例）；最后使用`Match`实例获得信息，进行其他操作。

1、`re`模块定义的几个函数、常量、异常：

在Python 3.6以上版本，Flag常量现在是RegexFlag（它是`enum.IntFlag`的子类）的实例。

1.1、`re.compile(pattern[, flags=0])`

它是`Pattern`类的工厂方法，将字符串形式的正则表达式模式 编译成正则表达式对象（`Pattern`对象），可以使用正则表达式对象的`match()`、`search()`、和其他方法进行匹配（下一节讲述）。

其中，第二个参数`flags` 是匹配模式，取值可使用按位或运算符 `|` 表示同时生效，比如`re.I | re.M`。另外，也可在regex字符串中指定模式，比如`re.compile('pattern', re.I | re.M)`与`re.compile('(?im)pattern')`是等价的。

`flags` 可选值有：

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>re.A</code>（<code>re.ASCII</code>）</td> 
   <td>使 <code>\w</code>、<code>\W</code>、<code>\b</code>、<code>\B</code>、<code>\d</code>、<code>\D</code>、<code>\s</code>、<code>\S</code>只执行ASCII匹配，而不是完整的Unicode匹配。PS：为了向后兼容，<code>re.U</code>标志仍然存在（以及<code>re.Unicode</code> 和<code>(?u)</code>）。但在Python 3中，这些是多余的，因为默认情况下，字符串的匹配是Unicode（字节不允许Unicode匹配）。</td> 
  </tr> 
  <tr> 
   <td><code>re.DEBUG</code></td> 
   <td>显示有关编译表达式的调试信息</td> 
  </tr> 
  <tr> 
   <td><code>re.I</code>（<code>re.IGNORECASE</code>）</td> 
   <td>执行不区分大小写的匹配。如：表达式[A-Z]将匹配小写字母。</td> 
  </tr> 
  <tr> 
   <td><code>re.L</code>（<code>re.LOCALE</code>）</td> 
   <td>使预定字符类 <code>\w</code>、 <code>\W</code>、 <code>\b</code> 、<code>\B</code> 取决于当前区域设定。PS：Python 3.6以上，<code>re.LOCALE</code>只用于字节模式，与<code>re.ASCII</code>不兼容。</td> 
  </tr> 
  <tr> 
   <td><code>re.M</code>（<code>re.MULTILINE</code>）</td> 
   <td>多行模式，改变 <code>^</code>和<code>$</code>的行为。</td> 
  </tr> 
  <tr> 
   <td><code>re.S</code>（<code>re.DOTALL</code>）</td> 
   <td>点任意匹配模式，改变 <code>.</code> 行为。</td> 
  </tr> 
  <tr> 
   <td><code>re.X</code>（<code>re.VERBOSE</code>）</td> 
   <td>详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。</td> 
  </tr> 
 </tbody> 
</table>

关于`re.VERBOSE`，以下两个正则表达式是等价的：

a = re.compile(r"""\d +  # the integral part
                       \.    # the decimal point
                       \d *  # some fractional digits""", re.X)
    b = re.compile(r"\d+\.\d*")

`re`提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用`Pattern`实例的相应方法替代，唯一的好处是少写一行`re.compile()`代码，但同时也无法复用编译后的`Pattern`对象。这些方法将在`Pattern`类的实例方法部分一起介绍。如上面这个例子可以简写为：

m = re.match(r'hello', 'hello world!')
    print(m.group())

`re`模块还提供了一个方法`escape(string)`，用于将`string`中的正则表达式元字符如`*/+/?`等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。

1.2、`re.search(pattern, string, flags=0)`  
扫描字符串，查找正则表达式模式产生匹配的第一个位置，并返回相应的匹配对象。如果字符串中没有位置与模式匹配，则返回`None`；注意，这跟查找字符串中某个点的零长度匹配不同。

1.3、`re.match(pattern, string, flags=0)`  
如果字符串开头的0个 或多个字符 与正则表达式模式匹配，则返回相应的匹配对象。如果字符串与模式不匹配，则返回`None`；注意，这跟0长度匹配不同。

PS：即使在MULTILINE模式下，`re.match()`将只在字符串的开始匹配，而不是在每行的开头匹配。

如果想在字符串中的任何位置找到匹配项，则使用`search()`。

1.4、`re.fullmatch(pattern, string, flags=0)`

Python 3.4新增的。  
如果整个字符串与正则表达式模式匹配，则返回相应的匹配对象。  
如果字符串与模式不匹配，则返回`None`；注意，这也与0长度匹配不同。

1.5、`re.split(pattern, string, maxsplit=0, flags=0)`  
通过正则表达式将字符串分割（正则表达式作为分割符）。如果用括号将正则表达式括起来，那么匹配的字符串也会被列出到`list`中返回。参数 `maxsplit`是分割的次数，默认为`0`；在`非0`时，最多发生`maxsplit`次拆分，并且字符串的其余部分作为列表的最后元素返回。参数`flags`在Python 3.1增加的；

C:\Users\Administrator>python
    Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import re
    >>> re.split(r"\W+", "Words,words,words.")#用r"\W+"匹配1次或多次非单词字符，并将它作为分割字符串的模式。. 也算，所以它后面是空字符。
    ['Words', 'words', 'words', '']
    >>> re.split(r"(\W+)", "Words,words,words.")#匹配的字符串也出现在列表中
    ['Words', ',', 'words', ',', 'words', '.', '']
    >>> re.split(r"\W+", "Words,words,words.", 1)#分割1次
    ['Words', 'words,words.']
    >>> re.split("[a-f]+", "0a3B9", flags=re.IGNORECASE)#匹配模式忽略大小写，以字母作为分割字符串的模式。结果是得到分割的数字。
    ['0', '3', '9']

如果分割符用括号括起（分组捕获）且它正好匹配到字符串的开头，得出的结果将以空字符串开头。同样适用于结尾。

>>> re.split(r'(\W+)', '...words, words...')
    ['', '...', 'words', ', ', 'words', '...', '']

这样，分隔符组件总是在结果列表中找到相同的相对索引。

PS：split()不会用一个空模式匹配去分割一个字符串。例：即使`'x*'`可以匹配到 0个`'x'`，但不会返回这个结果`['', 'a', 'b', 'c', '']`。例子正确的结果是匹配到1个`'x'`。

>>> re.split('x*', 'axbc')
    ['a', 'bc']

在Python3.5中，如果匹配模式为空，那么将引发`ValueError`：

>>> re.split("^$", "foo\n\nbar\n", flags=re.M)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      ...
    ValueError: split() requires a non-empty pattern match.

1.6、`re.findall(pattern, string, flags=0)`  
以列表形式返回字符串中所有非重叠的匹配模式。字符串从左到右扫描，并按找到的顺序返回匹配项。如果模式中存在一个或多个组，则返回组列表；如果模式有多个组，则返回元组列表。结果中包含空匹配。

>>>findall(r'^|\w+', 'two words')
    ['', 'wo', 'words']

PS：由于当前实现的限制，空匹配后面的字符不包括在下一个匹配中。因此，上述结果中没有“t”。这在Python 3.7改了。  
正则表达式 `r'^|\w+'`表示匹配空字符串开头 或 单词字符开头。`|` 从左到右进行匹配，一旦左边匹配成功，就会跳过右边表达式匹配。

1.7、`re.finditer(pattern, string, flags=0)`  
返回一个迭代器，它在字符串中的RE模式的所有非重叠匹配中产生匹配对象。字符串从左到右扫描，并按找到的顺序返回匹配项。结果中包含空匹配。可参考`findall()`。

1.8、`re.sub(pattern, repl, string, count=0, flags=0)`  
sub，substitute缩写，译作 替换。  
利用正则表达式，实现比普通字符串的replace更加强大的替换功能。  
`pattern`，表示正则表达式的模式字符串，可以是一个字符串或一个`pattern`对象；若pattern未提供，则将返回原字符串。  
`repl`，可以是一个字符串或一个函数。  
如果是一个字符串，则将处理其中任何一个反斜杠 `\` 转义，也就是说 `\n` 转换为单个换行符、`\r`转换为回车符等，对于未知的转义 如 `\&`将识别为它本身，而反向引用（如`\6`）表示匹配pattern的第6个group。  
PS：`pattern`若由`\` 和`ASCII`字母组成的未知转义，将会`error`。

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*$\s*$:', r'static PyObject*\npy_\1(void)\n{',  'def myfunc():')
    'static PyObject*\npy_myfunc(void)\n{'

如果`repl`是一个函数，举例：

>>> def dashrepl(matchobj):
    ...     if matchobj.group(0) == '-': return ' '
    ...     else: return '-'
    >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
    'pro--gram files'
    >>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
    'Baked Beans & Spam'

`count`，替换的最大次数。

1.9、`re.subn(pattern, repl, string, count=0, flags=0)`  
执行操作和sub()相似，但返回一个元组`(new_string, number_of_subs_made)`。包括新字符串、替换次数。

1.10、`re.escape(pattern)`  
转义pattern中所有字符，但ASCII字母、数字、‘\_’除外。如果想匹配一个其中包含正则表达式元字符的字符串，这将非常有用。

>>> print(re.escape('python.exe'))
    python\.exe
    
    >>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
    >>> print('[%s]+' % re.escape(legal_chars))
    [abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^_\`\|\~\:]+
    
    >>> operators = ['+', '-', '*', '/', '**']
    >>> print('|'.join(map(re.escape, sorted(operators, reverse=True))))
    \/|\-|\+|\*\*|\*

这个函数不可用在`sub()`、`subn()`替换字符串中，只有反斜杠被转义。例：

>>> digits_re = r'\d+'
    >>> sample = '/usr/sbin/sendmail - 0 errors, 12 warnings'
    >>> print(re.sub(digits_re, digits_re.replace('\\', r'\\'), sample))
    /usr/sbin/sendmail - \d+ errors, \d+ warnings

1.11、`re.purge()`  
purge，译作 清除、净化。  
清理正则表达式缓存。

1.12、异常 `re.error(msg, pattern=None, pos=None)`  
当传递给函数之一的字符串 不是有效的正则表达式、或在编译或匹配期间发生其他错误时，引发的异常。

`re.error()`实例的属性有：`msg`、`pattern`、`pos`、`lineno`、`colno`。

2、正则表达式对象 `pattern`

正则表达式编译后的对象（regular expression object）支持如下方法和属性：

2.1、`regex.search(string[, pos[, endpos]])`  
扫描字符串查找出正则表达式产生匹配的第一个位置，并返回一个对应的`match`对象。假如在字符串中没有匹配到`pattern`的位置，则返回`None`；不过这跟在字符串中某个点找到0长度匹配不同。

参数 `pos`，是可选的，表示搜索的开始索引，默认是0。这不同于字符串切片。`'^'`模式字符 在字符串的真正开始处、换行符之后的位置匹配，但不一定在搜索开始的索引处匹配。

参数`endpos`，也是可选的，限制了搜索字符串的距离；若`endpos`是字符串的长度，那么将只搜索从`pos`到`endpos-1`的字符进行匹配；若`endpos`<`pos`，则找不到匹配；另外，若`rx`是编译后的正则表达式对象，那么`rx.search(string, 0, 50)` 等价于`rx.search(string[:50], 0)`。

>>> pattern = re.compile("d")
    >>> pattern.search("dog")     # Match at index 0
    <_sre.SRE_Match object; span=(0, 1), match='d'>
    >>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

2.2、`regex.match(string[, pos[, endpos]])`  
假如在string的开头匹配到这个正则表达式的0个或多字符，将返回一个对应的`match`对象。假如没有匹配到，返回`None`。  
可选参数`pos`、`endpos`参照`regex.search()`。

>>> pattern = re.compile("o")
    >>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
    >>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
    <_sre.SRE_Match object; span=(1, 2), match='o'>

`search()` VS `match()`区别：  
`re.match()`检查的只是字符串的开头；  
`re.search()`检查的是字符串的任何位置。

>>> re.match("c", "abcdef")    # No match
    >>> re.search("c", "abcdef")   # Match
    <_sre.SRE_Match object; span=(2, 3), match='c'>

正则表达式 以`'^'`开头用到`search()`中，将会严格匹配到字符串的开头位置：

>>> re.match("c", "abcdef")    # No match
    >>> re.search("^c", "abcdef")  # No match
    >>> re.search("^a", "abcdef")  # Match
    <_sre.SRE_Match object; span=(0, 1), match='a'>

2.3、`regex.fullmatch(string[, pos[, endpos]])`这是Python 3.4新增的。  
如果整个字符串与正则表达式匹配，则返回对应的match对象；否则，返回`None`。

>>> pattern = re.compile("o[gh]")
    >>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
    >>> pattern.fullmatch("ogre")     # No match as not the full string matches.
    >>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
    <_sre.SRE_Match object; span=(1, 3), match='og'>

2.4、`regex.split(string, maxsplit=0)`  
使用了编译后的pattern后，与`re.spilt()`相同。

2.5、`regex.findall(string[, pos[, endpos]])`  
使用了编译后的pattern后，与`re.findall()`相似。加上`pos`、`endpos`参数，就跟`re.search()`相似了。

2.6、`regex.finditer(string[, pos[, endpos]])`  
使用了编译后的pattern后，与`re.finditer()`相似。加上`pos`、`endpos`参数，就跟`re.search()`相似了。

2.7、`regex.sub(repl, string, count=0)`  
使用了编译后的pattern后，与`re.sub()`相同。

2.8、`regex.subn(repl, string, count=0)`  
使用了编译后的pattern后，与`re.subn()`相同。

2.9、`regex.flags`  
这是正则表达式匹配的标志。是提供给compile()的标志组合，(?..)在pattern中的内联标志；假如pattern是Unicode字符串，则是隐式标志（如 UNICODE）。

2.10、`regex.groups`  
在pattern中捕获的group序号。

2.11、`regex.groupindex`  
2.12、`regex.pattern`  
编译了的RE对象的pattern字符串。

3、匹配对象

`Match`对象支持如下方法和属性：

3.1、`match.expand(template)`  
返回一个字符串，它是通过在字符串模板做反斜杠替换取得的，如同`sub()`方法。诸如`\n`之类的转义被转换为适当的字符，且数字反向引用（如 `\1`，`\2`）、命名反向引用（`\g<1>`，`\g<name>`）被相应group的内容替换。  
Python 3.5更改了：未匹配到的group将以空字符串替换。

3.2、`match.group([group1, ...])`  
返回一个或多个匹配的子组。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
    >>> m.group(0)       # The entire match
    'Isaac Newton'
    >>> m.group(1)       # The first parenthesized subgroup.
    'Isaac'
    >>> m.group(2)       # The second parenthesized subgroup.
    'Newton'
    >>> m.group(1, 2)    # Multiple arguments give us a tuple.
    ('Isaac', 'Newton')
    
    >>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
    >>> m.group('first_name')
    'Malcolm'
    >>> m.group('last_name')
    'Reynolds'
    >> m.group(1)
    'Malcolm'
    >>> m.group(2)
    'Reynolds'
    
    >>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
    >>> m.group(1)                        # Returns only the last match.
    'c3'

3.3、`match.__getitem__(g)`：这是Python 3.6新增的。  
它等同于`m.group(g)`。它更容易从匹配中访问单个group。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
    >>> m[0]       # The entire match
    'Isaac Newton'
    >>> m[1]       # The first parenthesized subgroup.
    'Isaac'
    >>> m[2]       # The second parenthesized subgroup.
    'Newton'

3.4、`match.groups(default=None)`  
返回一个包含匹配的所有子组的元组。

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
    >>> m.groups()
    ('24', '1632')
    
    >>> m = re.match(r"(\d+)\.?(\d+)?", "24")
    >>> m.groups()      # Second group defaults to None.
    ('24', None)
    >>> m.groups('0')   # Now, the second group defaults to '0'.
    ('24', '0')

3.5、`match.groupdict(default=None)`  
返回一个包含匹配到的所有命名子组的字典。

>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
    >>> m.groupdict()
    {'first_name': 'Malcolm', 'last_name': 'Reynolds'}

3.6、`match.start([group])`和`match.end([group])`  
返回由group匹配的子字符串的开始、结束的索引。

>>> email = "tony@tiremove_thisger.net"
    >>> m = re.search("remove_this", email)
    >>> email[:m.start()] + email[m.end():]
    'tony@tiger.net'

3.7、`match.span([group])`  
对于一个`match` `m`，返回一个元组`(m.start(group), m.end(group))`。

3.8、`match.pos`和`match.endpos`  
`pos`和`endpos`的值 正是传递给regex对象的方法`search()`或`match()`的。

3.9、`match.lastindex`  
得到最后一个匹配的捕获的group的索引。没有的话，则是`None`。

3.10、`match.lastgroup`  
得到最后一个匹配的捕获的group的名字。没有则返回None。

3.11、`match.re`  
`match()`或`search()`方法产生的match实例的正则表达式对象。

3.12、`match.string`  
取得传递给`match()`或`search()`方法的string。

4、正则表达式 官方示例

扑克牌找对子  
玩家手中有5张扑克牌，分别对应5个字符，那么5张牌就是一个包含5个字符的字符串。其中，a表示王；k表示国王；q表示女王；j表示杰克；t表示10；2-9表示本身的值。

首先、用一个helper function优雅地显示匹配对象：

def displaymatch(match):
        if match is None:
            return None
        return '<Match: %r, groups=%r>' % (match.group(), match.groups())

其次，检查手中的牌是否有效：

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")
    >>> displaymatch(valid.match("akt5q"))  # Valid.
    "<Match: 'akt5q', groups=()>"
    >>> displaymatch(valid.match("akt5e"))  # Invalid.
    >>> displaymatch(valid.match("akt"))    # Invalid.
    >>> displaymatch(valid.match("727ak"))  # Valid.
    "<Match: '727ak', groups=()>"

然后，检查手中牌是否有对子：

>>> pair = re.compile(r".*(.).*\1")
    >>> displaymatch(pair.match("717ak"))     # Pair of 7s.
    "<Match: '717', groups=('7',)>"
    >>> displaymatch(pair.match("718ak"))     # No pairs.
    >>> displaymatch(pair.match("354aa"))     # Pair of aces.
    "<Match: '354aa', groups=('a',)>"

最后，找出对子是啥：

>>> pair.match("717ak").group(1)
    '7'
    
    # Error because re.match() returns None, which doesn't have a group() method:
    >>> pair.match("718ak").group(1)
    Traceback (most recent call last):
      File "<pyshell#23>", line 1, in <module>
        re.match(r".*(.).*\1", "718ak").group(1)
    AttributeError: 'NoneType' object has no attribute 'group'
    
    >>> pair.match("354aa").group(1)
    'a'

参考：  
[Python 3.6 官方文档----`re`模块][Python 3.6 _----_re]

[70]: /images/20220504/01dfc36473624f81aec40d29c8c4a1e9.png
[70 1]: /images/20220504/d106eb077e8d48038294cbc1718b67a8.png
[70 2]: /images/20220504/1834ab31d4664a419116c3718f7a5760.png
[Python 3.6 _----_re]: https://docs.python.org/3.6/library/re.html