Python正则表达式

怼烎@ 2022-02-24 15:40 370阅读 0赞

re 模块使 Python 语言拥有全部的正则表达式功能。  
ref: [http://www.runoob.com/python/python-reg-expressions.html][http_www.runoob.com_python_python-reg-expressions.html]

## re模块常用函数 ##

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>re.match()</td> 
   <td>尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none</td> 
  </tr> 
  <tr> 
   <td>re.search()</td> 
   <td>扫描整个字符串并返回第一个成功的匹配</td> 
  </tr> 
  <tr> 
   <td>re.sub()</td> 
   <td>查找并替换</td> 
  </tr> 
  <tr> 
   <td>re.compile()</td> 
   <td>编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用</td> 
  </tr> 
  <tr> 
   <td>re.finditer()</td> 
   <td>找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回</td> 
  </tr> 
  <tr> 
   <td>re.split()</td> 
   <td>按照能够匹配的子串将字符串分割后返回列表</td> 
  </tr> 
  <tr> 
   <td>re.findall()</td> 
   <td>在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表</td> 
  </tr> 
 </tbody> 
</table>

#### re.match(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>标志位，用于控制正则表达式的匹配方式</td> 
  </tr> 
 </tbody> 
</table>

返回值类型：成功匹配返回一个匹配对象，否则返回None  
匹配对象的方法（*用匹配对象调用方法即可*）

<table> 
 <thead> 
  <tr> 
   <th>匹配对象方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>group(num)</td> 
   <td>匹配的第num（num&gt;=1）个分组的结果值</td> 
  </tr> 
  <tr> 
   <td>group( )或者group(0)</td> 
   <td>表示匹配到的完整文本字符</td> 
  </tr> 
  <tr> 
   <td>groups()</td> 
   <td>返回一个包含所有小组字符串的元组，(match1, match2, match3)</td> 
  </tr> 
 </tbody> 
</table>

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

用法同re.match()

#### re.compile(pattern, flags) ####

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。  
pattern : 一个字符串形式的正则表达式  
flags : 可选，表示匹配模式

prog = re.compile(pattern,flags)#编译生成正则表达式对象prog
    result = prog.match(string)#result 为返回的匹配对象，使用group(num)方法访问匹配结果

#### findall(string\[, pos\[, endpos\]\]) ####

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。  
**注意： match 和 search 是匹配一次 findall 匹配所有。**

参数：  
string : 待匹配的字符串。  
pos : 可选参数，指定字符串的起始位置，默认为 0。  
endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

返回值：匹配结果列表

import re
    pattern = re.compile(r'\d+')   # 查找数字
    result1 = pattern.findall('runoob 123 google 456')
    result2 = pattern.findall('run88oob123google456', 0, 10)
    print(result1) #结果['123', '456']
    print(result2)  #结果['88', '12']

#### re.finditer(pattern, string, flags=0) ####

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

#### re.sub(pattern, repl, string, count=0, flags=0) ####

查找并替换  
repl : 替换的字符串，也可为一个函数。  
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

## 正则表达式修饰符 - 可选标志 ##

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

<table> 
 <thead> 
  <tr> 
   <th>修饰符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <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>

## 正则表达式模式 ##

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>^</td> 
   <td>匹配字符串的开头</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>匹配字符串的末尾。</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。</td> 
  </tr> 
  <tr> 
   <td>[…]</td> 
   <td>用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’</td> 
  </tr> 
  <tr> 
   <td>[^…]</td> 
   <td>不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。</td> 
  </tr> 
  <tr> 
   <td>re*</td> 
   <td>匹配0个或多个的表达式。</td> 
  </tr> 
  <tr> 
   <td>re+</td> 
   <td>匹配1个或多个的表达式。</td> 
  </tr> 
  <tr> 
   <td>re?</td> 
   <td>匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式</td> 
  </tr> 
  <tr> 
   <td>re{ n}</td> 
   <td>精确匹配 n 个前面表达式。如o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。</td> 
  </tr> 
  <tr> 
   <td>re{ n,}</td> 
   <td>匹配 n 个前面表达式。例如，o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有o。“o{1,}” 等价于 “o+”。“o{0,}” 则等价于 “o*”。</td> 
  </tr> 
  <tr> 
   <td>re{ n,m}</td> 
   <td>匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>b 匹配a或b</td> 
  </tr> 
  <tr> 
   <td>(re)</td> 
   <td>匹配括号内的表达式，也表示一个组</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>(?&gt; re)</td> 
   <td>匹配的独立模式，省去回溯。</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>匹配字母数字及下划线</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>匹配非字母数字及下划线</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配任意空白字符，等价于 [\t\n\r\f].</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配任意非空字符</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>匹配任意数字，等价于 [0-9].</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>匹配任意非数字</td> 
  </tr> 
  <tr> 
   <td>\A</td> 
   <td>匹配字符串开始</td> 
  </tr> 
  <tr> 
   <td>\Z</td> 
   <td>匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。</td> 
  </tr> 
  <tr> 
   <td>\z</td> 
   <td>匹配字符串结束</td> 
  </tr> 
  <tr> 
   <td>\G</td> 
   <td>匹配最后匹配完成的位置。</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。</td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td>匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。</td> 
  </tr> 
  <tr> 
   <td>\n, \t, 等.</td> 
   <td>匹配一个换行符。匹配一个制表符。等</td> 
  </tr> 
  <tr> 
   <td>\1…\9</td> 
   <td>匹配第n个分组的内容。</td> 
  </tr> 
  <tr> 
   <td>\10</td> 
   <td>匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。</td> 
  </tr> 
 </tbody> 
</table>

## 正则表达式分组 ##

分组就是用一对圆括号“()”括起来的正则表达式，匹配出的内容就表示一个分组。从正则表达式的左边开始看，看到的第一个左括号“(”表示第一个分组，第二个表示第二个分组，依次类推，需要注意的是，有一个隐含的全局分组（就是0），就是整个正则表达式。  
分完组以后，要想获得某个分组的内容，直接使用group(num)和groups()函数去直接提取就行。

import re
    line = "my Cats are smarter than dogs"
    matchObj = re.match(r'.* (.*?) are ([a-z]*?) .*', line, re.M|re.I)
    if matchObj:
        print("matchObj.group() : ", matchObj.group())
        print("matchObj.group(0) : ", matchObj.group(0))
        print("matchObj.group(1) : ", matchObj.group(1))
        print("matchObj.group(2) : ", matchObj.group(2))
    else:
        print("No match!!")
    # matchObj.group() :  my Cats are smarter than dogs
    # matchObj.group(0) :  my Cats are smarter than dogs
    # matchObj.group(1) :  Cats
    # matchObj.group(2) :  smarter

解析:  
 首先，这是一个字符串，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个 r 可有可无。  
(.\*) 第一个匹配分组，.\* 代表匹配除换行符之外的所有字符。  
(.\*?) 第二个匹配分组，.\*? 中问号代表非贪婪模式，只匹配符合条件的最少字符  
后面的一个 .\* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。  
matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符  
matchObj.group(1) 得到第一组匹配结果，也就是(.\*)匹配到的  
matchObj.group(2) 得到第二组匹配结果，也就是(.\*?)匹配到的

## 实例 ##

import re
    
    
    def main():
        test = 'Welcome to Shtomanghai!'
        pattern = re.compile('[tc]om', re.S)
        resultlist = re.findall(pattern, test)
        if resultlist:
            print(resultlist)
            return
        else:
            print('Match Not Found!')
    
    
    if __name__ == '__main__':
        main()

[http_www.runoob.com_python_python-reg-expressions.html]: http://www.runoob.com/python/python-reg-expressions.html