Python常用模块6-Python的re模块简介

偏执的太偏执、 2022-11-16 13:51 246阅读 0赞

### 文章目录 ###

*  一.re模块简介
 *   *  1.1 匹配符
     *   *  1.1.1 字符集合
         *  1.1.2 重复次数
         *  1.1.3 组合匹配符
 *  二.模块内容
 *   *  2.1 常用函数
     *  2.2 异常
     *  2.3 匹配对象
 *  三.正则案例
 *   *  3.1 re.search
     *  3.2 re.match
     *  3.3 re.fullmatch
     *  3.4 re.split
     *  3.5 re.findall
 *  参考:

# 一.re模块简介 #

这个模块提供了与 Perl 语言类似的正则表达式匹配操作。

模式和被搜索的字符串既可以是 Unicode 字符串 (str) ，也可以是8位字节串 (bytes)。 但是，Unicode 字符串与8位字节串不能混用：也就是说，你不能用一个字节串模式去匹配 Unicode 字符串，反之亦然；类似地，当进行替换操作时，替换字符串的类型也必须与所用的模式和搜索字符串的类型一致。

正则表达式使用反斜杠（’’）来表示特殊形式，或者把特殊字符转义成普通字符。 而反斜杠在普通的 Python 字符串里也有相同的作用，所以就产生了冲突。比如说，要匹配一个字面上的反斜杠，正则表达式模式不得不写成 ‘\\\\’，因为正则表达式里匹配一个反斜杠必须是 \\ ，而每个反斜杠在普通的 Python 字符串里都要写成 \\ 。

解决办法是对于正则表达式样式使用 Python 的原始字符串表示法；在带有 ‘r’ 前缀的字符串字面值中，反斜杠不必做任何特殊处理。 因此 r"\\n" 表示包含 ‘’ 和 ‘n’ 两个字符的字符串，而 “\\n” 则表示只包含一个换行符的字符串。 样式在 Python 代码中通常都会使用这种原始字符串表示法来表示。

绝大部分正则表达式操作都提供为模块函数和方法，在 编译正则表达式. 这些函数是一个捷径，不需要先编译一个正则对象，但是损失了一些优化参数。

**第三方模块 [regex][] , 提供了与标准库 [`re`][re] 模块兼容的API接口, 同时还提供了额外的功能和更全面的Unicode支持。**

## 1.1 匹配符 ##

python的匹配符比较多，下面罗列一些常用的。

<table> 
 <thead> 
  <tr> 
   <th>常用配符</th> 
   <th>概述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.</td> 
   <td>(点) 在默认模式，匹配除了换行的任意字符。如果指定了标签 DOTALL ，它将匹配包括换行符的任意字符。</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>(插入符号) 匹配字符串的开头， 并且在 MULTILINE 模式也匹配换行后的首个符号</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>匹配字符串尾或者在字符串尾的换行符的前一个字符，在 MULTILINE 模式下也会匹配换行符之前的文本。</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>对它前面的正则式匹配0到任意次重复， 尽量多的匹配字符串。 ab* 会匹配 ‘a’，‘ab’，或者 ‘a’ 后面跟随任意个 ‘b’。</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>对它前面的正则式匹配1到任意次重复。 ab+ 会匹配 ‘a’ 后面跟随1个以上到任意个 ‘b’，它不会匹配 ‘a’。</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>对它前面的正则式匹配0到1次重复。 ab? 会匹配 ‘a’ 或者 ‘ab’。</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>转义特殊字符（允许你匹配 ‘*’, ‘?’, 或者此类其他），或者表示一个特殊序列；特殊序列之后进行讨论。</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>A|B, 匹配A或者B，A成功了，就不会匹配B</td> 
  </tr> 
  <tr> 
   <td>[]</td> 
   <td>用于表示一个字符集合,比如 [amk] 匹配 ‘a’， ‘m’， 或者 ‘k’</td> 
  </tr> 
 </tbody> 
</table>

### 1.1.1 字符集合 ###

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>匹配的字符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\number</td> 
   <td>匹配数字代表的组合。</td> 
  </tr> 
  <tr> 
   <td>\A</td> 
   <td>只匹配字符串开始</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>匹配空字符串，但只在单词开始或结尾的位置。</td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td>匹配空字符串，但 不 能在词的开头或者结尾</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>匹配任何十进制数，就是 [0-9]</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>匹配非[0-9]的数字，与\d 相反</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配ASCII中的空白字符，就是 [ \t\n\r\f\v] 。</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配任何不是空白字符的字符，与\s相反</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>匹配ASCII字符中的数字和字母和下划线，就是 [a-zA-Z0-9_] 。</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>匹配任何不是单词字符的字符，与\w相反</td> 
  </tr> 
  <tr> 
   <td>\Z</td> 
   <td>只匹配字符串尾。</td> 
  </tr> 
 </tbody> 
</table>

### 1.1.2 重复次数 ###

贪婪模式会获取尽可能多的字符，而非贪婪模式会获取尽可能少的字符。

<table> 
 <thead> 
  <tr> 
   <th>贪婪</th> 
   <th>非贪婪</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*</td> 
   <td>*?</td> 
   <td>零次或多次</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>??</td> 
   <td>零次或一次</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>+?</td> 
   <td>一次或多次</td> 
  </tr> 
  <tr> 
   <td>{m}</td> 
   <td>{m}?</td> 
   <td>正好m次，贪婪与非贪婪一样的，比如， a{6} 将匹配6个 ‘a’</td> 
  </tr> 
  <tr> 
   <td>{m,}</td> 
   <td>{m,}?</td> 
   <td>至少m次， 比如 a{4,}b 将匹配 ‘aaaab’ 或者1000个 ‘a’ 尾随一个 ‘b’，但不能匹配 ‘aaab’</td> 
  </tr> 
  <tr> 
   <td>{m, n}</td> 
   <td>{m, n}?</td> 
   <td>最少m最多n次，比如，对于 ‘aaaaaa’， a{3,5} 匹配 5个 ‘a’ ，而 a{3,5}? 只匹配3个 ‘a’</td> 
  </tr> 
 </tbody> 
</table>

### 1.1.3 组合匹配符 ###

组合匹配是多个匹配规则配合起来。  
例如，我要匹配身份证号码

^[1-9]\d{ 13,16}[0-9x]$

上面这个代码有3个部分

1.  1 开头是1-9的一个数字
2.  \\d\{13,16\} 中间是最少13个数字，最多16个数字
3.  \[0-9xX\]$ 结尾是0-9、x或者X中的一个

<table> 
 <thead> 
  <tr> 
   <th>组合匹配符</th> 
   <th>概述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>(…)</td> 
   <td>（组合），匹配括号内的任意正则表达式，并标识出组合的开始和结尾。匹配完成后，组合的内容可以被获取，并可以在之后用 \number 转义序列进行再次匹配，之后进行详细说明。要匹配字符 ‘(’ 或者 ‘)’, 用 ( 或 ), 或者把它们包含在字符集合里: [(], [)].</td> 
  </tr> 
  <tr> 
   <td>(?…)</td> 
   <td>这是个扩展标记法 （一个 ‘?’ 跟随 ‘(’ 并无含义）。 ‘?’ 后面的第一个字符决定了这个构建采用什么样的语法。</td> 
  </tr> 
  <tr> 
   <td>(?aiLmsux)</td> 
   <td>( ‘a’, ‘i’, ‘L’, ‘m’, ‘s’, ‘u’, ‘x’ 中的一个或多个) 这个组合匹配一个空字符串；这</td> 
  </tr> 
  <tr> 
   <td>(?:…)</td> 
   <td>正则括号的非捕获版本。 匹配在括号内的任何正则表达式，但该分组所匹配的子字符串 不能 在执行匹配后被获取或是之后在模式中被引用。</td> 
  </tr> 
  <tr> 
   <td>(?#…)</td> 
   <td>注释；里面的内容会被忽略。</td> 
  </tr> 
  <tr> 
   <td>(?=…)</td> 
   <td>匹配 … 的内容，但是并不消费样式的内容。这个叫做 lookahead assertion。比如， Isaac (?=Asimov) 匹配 'Isaac ’ 只有在后面是 ‘Asimov’ 的时候。</td> 
  </tr> 
  <tr> 
   <td>(?!…)</td> 
   <td>匹配 … 不符合的情况。这个叫 negative lookahead assertion （前视取反）。比如说， Isaac (?!Asimov) 只有后面 不 是 ‘Asimov’ 的时候才匹配 'Isaac ’ 。</td> 
  </tr> 
  <tr> 
   <td>(?&lt;=…)</td> 
   <td>匹配字符串的当前位置，它的前面匹配 … 的内容到当前位置</td> 
  </tr> 
  <tr> 
   <td>(?&lt;!…)</td> 
   <td>匹配当前位置之前不是 … 的样式。</td> 
  </tr> 
  <tr> 
   <td>(?(id/name)yes-pattern|no-pattern)</td> 
   <td>如果给定的 id 或 name 存在，将会尝试匹配 yes-pattern ，否则就尝试匹配 no-pattern，no-pattern 可选，也可以被忽略。</td> 
  </tr> 
 </tbody> 
</table>

# 二.模块内容 #

模块定义了几个函数，常量，和一个例外。有些函数是编译后的正则表达式方法的简化版本（少了一些特性）。绝大部分重要的应用，总是会先将正则表达式编译，之后在进行操作。

## 2.1 常用函数 ##

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>概述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>re.compile(pattern, flags=0)</td> 
   <td>将一个正则表达式模式编译成一个正则表达式对象，可以使用它的match()、search()和其他方法进行匹配,如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。</td> 
  </tr> 
  <tr> 
   <td>re.I/re.IGNORECASE</td> 
   <td>进行忽略大小写匹配；表达式如 [A-Z] 也会匹配小写字符。Unicode匹配（比如 Ü 匹配 ü）同样有用，除非设置了 re.ASCII 标记来禁用非ASCII匹配。当前语言区域不会改变这个标记，除非设置了 re.LOCALE 标记。这个相当于内联标记</td> 
  </tr> 
  <tr> 
   <td>re.L/re.LOCALE</td> 
   <td>由当前语言区域决定 \w, \W, \b, \B 和大小写敏感匹配。这个标记只能对byte样式有效。这个标记不推荐使用，因为语言区域机制很不可靠，它一次只能处理一个 “习惯”，而且只对8位字节有效。</td> 
  </tr> 
  <tr> 
   <td>re.M/re.MULTILINE</td> 
   <td>设置以后，样式字符 ‘^’ 匹配字符串的开始，和每一行的开始（换行符后面紧跟的符号）；样式字符 ‘<span><span><span> ′ 匹 配 字 符 串 尾 ， 和 每 一 行 的 结 尾 （ 换 行 符 前 面 那 个 符 号 ） 。 默 认 情 况 下 ， ’ ’ 匹 配 字 符 串 头 ， ′ ' 匹配字符串尾，和每一行的结尾（换行符前面那个符号）。默认情况下，’^’ 匹配字符串头，' </span><span><span><span style="height: 0.849108em; vertical-align: 0em;"></span><span><span></span><span><span><span><span style="height: 0.751892em;"><span style="top: -3.063em; margin-right: 0.05em;"><span style="height: 2.7em;"></span><span><span><span>′</span></span></span></span></span></span></span></span></span><span>匹</span><span>配</span><span>字</span><span>符</span><span>串</span><span>尾</span><span>，</span><span>和</span><span>每</span><span>一</span><span>行</span><span>的</span><span>结</span><span>尾</span><span>（</span><span>换</span><span>行</span><span>符</span><span>前</span><span>面</span><span>那</span><span>个</span><span>符</span><span>号</span><span>）</span><span>。</span><span>默</span><span>认</span><span>情</span><span>况</span><span>下</span><span>，</span><span><span>’</span><span><span><span><span style="height: 0.849108em;"><span style="top: -3.063em; margin-right: 0.05em;"><span style="height: 2.7em;"></span><span><span>’</span></span></span></span></span></span></span></span><span>匹</span><span>配</span><span>字</span><span>符</span><span>串</span><span>头</span><span><span>，</span><span><span><span><span style="height: 0.751892em;"><span style="top: -3.063em; margin-right: 0.05em;"><span style="height: 2.7em;"></span><span><span><span>′</span></span></span></span></span></span></span></span></span></span></span></span></span>’ 匹配字符串尾。对应内联标记 (?m) 。</td> 
  </tr> 
  <tr> 
   <td>re.S/re.DOTALL</td> 
   <td>让 ‘.’ 特殊字符匹配任何字符，包括换行符；如果没有这个标记，’.’ 就匹配 除了 换行符的其他任意字符。</td> 
  </tr> 
  <tr> 
   <td>re.X/re.VERBOSE</td> 
   <td>这个标记允许你编写更具可读性更友好的正则表达式。通过分段和添加注释。空白符号会被忽略，除非在一个字符集合当中或者由反斜杠转义，或者在 *?, (?: or (?P&lt;…&gt; 分组之内。当一个行内有 # 不在字符集和转义序列，那么它之后的所有字符都是注释。</td> 
  </tr> 
  <tr> 
   <td>re.search(pattern, string, flags=0)</td> 
   <td>扫描整个 字符串 找到匹配样式的第一个位置，并返回一个相应的 匹配对象。如果没有匹配，就返回一个 None ； 注意这和找到一个零长度匹配是不同的。</td> 
  </tr> 
  <tr> 
   <td>re.match(pattern, string, flags=0)</td> 
   <td>如果 string 开始的0或者多个字符匹配到了正则表达式样式，就返回一个相应的 匹配对象 。 如果没有匹配，就返回 None ；注意它跟零长度匹配是不同的。<br>注意即便是 MULTILINE 多行模式， re.match() 也只匹配字符串的开始位置，而不匹配每行开始。<br>如果你想定位 string 的任何位置，使用 search() 来替代（也可参考 search() vs. match() ）</td> 
  </tr> 
  <tr> 
   <td>re.fullmatch(pattern, string, flags=0)</td> 
   <td>如果整个 string 匹配到正则表达式样式，就返回一个相应的 匹配对象 。 否则就返回一个 None ；注意这跟零长度匹配是不同的</td> 
  </tr> 
  <tr> 
   <td>re.split(pattern, string, maxsplit=0, flags=0)</td> 
   <td>用 pattern 分开 string 。 如果在 pattern 中捕获到括号，那么所有的组里的文字也会包含在列表里。如果 maxsplit 非零， 最多进行 maxsplit 次分隔， 剩下的字符全部返回到列表的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>re.findall(pattern, string, flags=0)</td> 
   <td>对 string 返回一个不重复的 pattern 的匹配列表， string 从左到右进行扫描，匹配按找到的顺序返回。如果样式里存在一到多个组，就返回一个组合列表；就是一个元组的列表（如果样式里有超过一个组合的话）。空匹配也会包含在结果里。</td> 
  </tr> 
  <tr> 
   <td>re.escape(pattern)</td> 
   <td>转义除ASCII字母、数字和’_'之外的模式中的所有字符。如果您想要匹配任意可能包含正则表达式元字符的字面值字符串，这是非常有用的</td> 
  </tr> 
  <tr> 
   <td>re.purge()</td> 
   <td>清除正则表达式缓存。</td> 
  </tr> 
 </tbody> 
</table>

## 2.2 异常 ##

exception re.error(msg, pattern=None, pos=None)  
raise 一个例外。当传递到函数的字符串不是一个有效正则表达式的时候（比如，包含一个不匹配的括号）或者其他错误在编译时或匹配时产生。如果字符串不包含样式匹配，是不会被视为错误的。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>msg</td> 
   <td>未格式化的错误消息。</td> 
  </tr> 
  <tr> 
   <td>pattern</td> 
   <td>正则表达式样式</td> 
  </tr> 
  <tr> 
   <td>pos</td> 
   <td>编译失败的 pattern 的位置索引（可以是 None ）。</td> 
  </tr> 
  <tr> 
   <td>lineno</td> 
   <td>对应 pos (可以是 None) 的行号。</td> 
  </tr> 
  <tr> 
   <td>colno</td> 
   <td>对应 pos (可以是 None) 的列号。</td> 
  </tr> 
 </tbody> 
</table>

## 2.3 匹配对象 ##

re.search、re.match、re.fullmatch、re.finditer 都支持匹配对象

匹配对象支持以下方法和属性

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>match.expand(template)</td> 
   <td>返回通过在模板字符串模板上执行反斜杠替换获得的字符串，就像sub()方法那样。转义(例如\n)被转换为适当的字符，数字反向引用(\1，\2)和命名反向引用(\g&lt;1&gt;， \g)被相应组的内容替换。</td> 
  </tr> 
  <tr> 
   <td>match.group([group1, …])</td> 
   <td>返回一个或者多个匹配的子组。如果只有一个参数，结果就是一个字符串，如果有多个参数，结果就是一个元组（每个参数对应一个项），如果没有参数，组1默认到0（整个匹配都被返回）。</td> 
  </tr> 
  <tr> 
   <td>match.<strong>getitem</strong>(g)</td> 
   <td>这个等价于 m.group(g)。这允许更方便的引用一个匹配</td> 
  </tr> 
  <tr> 
   <td>match.groups(default=None)</td> 
   <td>返回一个元组，包含所有匹配的子组，在样式中出现的从1到任意多的组合。 default 参数用于不参与匹配的情况，默认为 None。</td> 
  </tr> 
  <tr> 
   <td>match.groupdict(default=None)</td> 
   <td>返回一个字典，包含了所有的 命名 子组。key就是组名。 default 参数用于不参与匹配的组合；默认为 None</td> 
  </tr> 
  <tr> 
   <td>match.start([group])</td> 
   <td>返回 group 匹配到的字串的开始标号</td> 
  </tr> 
  <tr> 
   <td>match.end([group])</td> 
   <td>返回 group 匹配到的字串的结束标号</td> 
  </tr> 
  <tr> 
   <td>match.span([group])</td> 
   <td>对于一个匹配 m ， 返回一个二元组 (m.start(group), m.end(group))</td> 
  </tr> 
  <tr> 
   <td>match.pos</td> 
   <td>pos的值，传递给regex对象的search()或match()方法。这是RE引擎不能超越的字符串索引。</td> 
  </tr> 
  <tr> 
   <td>match.endpos</td> 
   <td>endpos的值，传递给regex对象的search()或match()方法。这是RE引擎不能超越的字符串索引。</td> 
  </tr> 
  <tr> 
   <td>match.lastindex</td> 
   <td>捕获组的最后一个匹配的整数索引值，或者 None 如果没有匹配产生的话。</td> 
  </tr> 
  <tr> 
   <td>match.lastgroup</td> 
   <td>最后一个匹配的命名组名字，或者 None 如果没有产生匹配的话。</td> 
  </tr> 
  <tr> 
   <td>match.re</td> 
   <td>match()或search()方法产生这个匹配实例的正则表达式对象</td> 
  </tr> 
  <tr> 
   <td>match.string</td> 
   <td>传递给match()或search()的字符串</td> 
  </tr> 
 </tbody> 
</table>

# 三.正则案例 #

## 3.1 re.search ##

语法:

re.search(pattern, string, flags=0)

函数参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pattern</td> 
   <td>匹配的正则表达式</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>要匹配的字符串</td> 
  </tr> 
  <tr> 
   <td>flags</td> 
   <td>标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等<br>re.I (ignore case), re.M (multi-line), re.S (dot matches all), and re.X (verbose)</td> 
  </tr> 
 </tbody> 
</table>

扫描整个 字符串 找到匹配样式的第一个位置，并返回一个相应的 匹配对象。如果没有匹配，就返回一个 None ； 注意这和找到一个零长度匹配是不同的。

代码:

import re
    
    
    # 匹配是否存在
    content1 = "I love python,I'm studying python!"
    result1 = re.search('python', content1)
    
    # 如果匹配成功输出结果,否则输出"匹配失败"
    if result1:
        print(result1.group())
    else:
        print("匹配失败")
    
    
    content2 = "I love python,I'm studying python!"
    result2 = re.search('test', content2)
    
    # 如果匹配成功输出结果,否则输出"匹配失败"
    if result2:
        print(result2.group())
    else:
        print("匹配失败")
    
    print("\n")
    # 匹配数字
    content = 'Hello 123456789 Word_This is just a test 666 Test'
    result = re.search('(\d+).*?(\d+).*', content)
    
    print(result)
    print(result.group())  # print(result.group(0)) 同样效果字符串
    print(result.groups())
    print(result.group(1))
    print(result.group(2))
    
    print(result.start())
    print(result.end())
    print(result.span())
    
    
    print("\n")
    # 匹配前3个单词
    content = 'Hello 123456789 Word_This is just a test 666 Test'
    result = re.search('([a-zA-Z]+).*?([a-zA-Z]+).*?([a-zA-Z]+)', content)
    
    # 输出匹配的结果,是一串字符
    print(result)
    print(result.string)
    
    # 输出group相关
    print(result.group())  # print(result.group(0)) 同样效果字符串
    print(result.groups())
    print(result.group(1))
    print(result.group(2))
    print(result.group(3))
    
    # 输出匹配的规则
    print(result.re)
    
    # 输出匹配开始和结尾 开始匹配的字符是 start+1
    print(result.start())
    print(result.end())
    print(result.span())
    
    # 输出字符的开始位置和结束位置
    print(result.pos)
    print(result.endpos)
    
    # 输出组最后的标记
    print(result.lastindex)
    print(result.lastgroup)

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/re_test1.py
    python
    匹配失败
    
    
    <_sre.SRE_Match object; span=(6, 49), match='123456789 Word_This is just a test 666 Test'>
    123456789 Word_This is just a test 666 Test
    ('123456789', '666')
    123456789
    666
    6
    49
    (6, 49)
    
    
    <_sre.SRE_Match object; span=(0, 25), match='Hello 123456789 Word_This'>
    Hello 123456789 Word_This is just a test 666 Test
    Hello 123456789 Word_This
    ('Hello', 'Word', 'This')
    Hello 123456789 Word_This
    Hello
    Word
    This
    re.compile('([a-zA-Z]+).*?([a-zA-Z]+).*?([a-zA-Z]+)')
    0
    25
    (0, 25)
    0
    49
    3
    None
    
    Process finished with exit code 0

## 3.2 re.match ##

语法:

re.match(pattern, string, flags=0)

函数参数说明：

如果 string 开始的0或者多个字符匹配到了正则表达式样式，就返回一个相应的 匹配对象 。 如果没有匹配，就返回 None ；注意它跟零长度匹配是不同的。  
注意即便是 MULTILINE 多行模式， re.match() 也只匹配字符串的开始位置，而不匹配每行开始。  
如果你想定位 string 的任何位置，使用 search() 来替代（也可参考 search() vs. match() ）

<table> 
 <thead> 
  <tr> 
   <th>匹配对象方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>group(num=0)</td> 
   <td>匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。</td> 
  </tr> 
  <tr> 
   <td>groups()</td> 
   <td>返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。</td> 
  </tr> 
 </tbody> 
</table>

Python 提供了两种不同的操作：基于 re.match() 检查字符串开头，或者 re.search() 检查字符串的任意位置（默认Perl中的行为）。

>>> 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'>
    
    -- 注意 MULTILINE 多行模式中函数 match() 只匹配字符串的开始，但使用 search() 和以 '^' 开始的正则表达式会匹配每行的开始
    >>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match
    >>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match
    <_sre.SRE_Match object; span=(4, 5), match='X'>

## 3.3 re.fullmatch ##

语法:

re.fullmatch(pattern, string, flags=0)

函数参数说明：

如果整个 string 匹配到正则表达式样式，就返回一个相应的匹配对象 。 否则就返回一个 None ；注意这跟零长度匹配是不同的。

match从字符串开头开始匹配，匹配到目标的字符串即可成功返回（这个要跟search区分开，search不要求从头开始匹配）；

fullmatch是完全匹配（从字符串开头到结尾）。

import re
    
    qq = '1826755263'
    re.match(r'[1-9]\d{4,11}', qq)
    
    qq = '1826755263'
    re.fullmatch(r'[1-9]\d{4,11}', qq)
    
    # 用match实现fullmatch的功能
    qq = '1826755263'
    re.match(r'^[1-9]\d{4,11}$', qq)

## 3.4 re.split ##

语法:

re.split(pattern, string, maxsplit=0, flags=0)

函数参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pattern</td> 
   <td>匹配的正则表达式</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>要匹配的字符串</td> 
  </tr> 
  <tr> 
   <td>maxsplit</td> 
   <td>分隔次数，默认为0(即不限次数)</td> 
  </tr> 
  <tr> 
   <td>flags</td> 
   <td>标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等<br>re.I (ignore case), re.M (multi-line), re.S (dot matches all), and re.X (verbose)</td> 
  </tr> 
 </tbody> 
</table>

用 pattern 分开 string 。 如果在 pattern 中捕获到括号，那么所有的组里的文字也会包含在列表里。如果 maxsplit 非零， 最多进行 maxsplit 次分隔， 剩下的字符全部返回到列表的最后一个元素

>>> import re
    >>> re.split(r'\W+','Words, words, words.')
    ['Words', 'words', 'words', '']
    >>> re.split(r'(\W+)','Words, words, words.')
    ['Words', ', ', 'words', ', ', 'words', '.', '']
    >>>
    >>> re.split(r'\W+','Words, words, words.',1)
    ['Words', 'words, words.']
    >>> re.split(r'\W+','Words, words, words.',2)
    ['Words', 'words', 'words.']
    >>>
    >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
    ['0', '3', '9']
    >>>

## 3.5 re.findall ##

语法:

re.findall(pattern, string, flags=0)

函数参数说明：

对 string 返回一个不重复的 pattern 的匹配列表， string 从左到右进行扫描，匹配按找到的顺序返回。如果样式里存在一到多个组，就返回一个组合列表；就是一个元组的列表（如果样式里有超过一个组合的话）。空匹配也会包含在结果里。

>>> import re
    >>> text = "He was carefully disguised but captured quickly by police."
    >>> re.findall(r"\w+ly", text)
    ['carefully', 'quickly']
    >>>

# 参考: #

1.https://docs.python.org/zh-cn/3.6/library/re.html  
2.https://blog.csdn.net/u011649536/article/details/50587915

--------------------

1.  1-9 ↩︎

[regex]: https://pypi.org/project/regex/
[re]: https://docs.python.org/zh-cn/3.6/library/re.html#module-re