re模块的功能介绍

1. 方法

1. match

   从开头开始查找

   方法：re.match(pattern,string,flags=0)
   返回值：<class ‘_sre.SRE_Match‘>（找到） or None（没找到）
   例如：m = re.match(‘e‘,‘excel‘)
        print(m.group())
    >>> ‘e‘
   #该方法只能从开头开始查，如果查找的内容不是开头或者不存在时，返回值为None，验证时调用group方法时将报错，如果找到了，也只有一个，验证时可以使用group方法进行获取查找的内容。
   

2. search

   全文搜索，只获取第一个

   方法：re.search(pattern,string,flags=0)
   返回值：<class ‘_sre.SRE_Match‘>（找到） or None（没找到）
   例如：s = re.search(‘ba‘,‘adbadfsbadsf‘)
        print(s.group())
    >>> ‘ba‘
   #该方法与上述方法类似，不过该方法查找的范围是全部内容，但返回只返回查找到的第一个，验证方法同上。
   

3. findall

   返回找到的所有内容（全文搜索）

   方法：re.findall(pattern,string,flags=0)
   返回值：list
   例如：print(re.findall(‘s‘,‘afadsfdsf‘))
    >>> [‘s‘,‘s‘]
   #该方法不需要通过group方法进行验证，找不到时返回一个空列表。
   

4. split

   搜索全文并进行切片

   方法：re.split(pattern,string,maxsplit=0,flags=0)
   返回值：list
   例如：print(re.split(‘ax‘,‘sdaxfsfsaxdfsax‘))
    >>> [‘sd‘, ‘fsfs‘, ‘dfs‘, ‘‘]
   #指定内容作为分割字符串的点进行切片，如果指定内容开头或者结果则结果为列表中的一个空字符串，同时也可以指定切片的最大次数。
   

5. sub

   替换

   方法：re.sub(pattern,repl,string,count=0,flags=0)
   返回值：str
   例如：print(re.sub(‘a‘,‘23‘,‘sdfafasdf‘))
    >>> ‘sdf23f23sdf‘
   #该方法默认全文替换，可以指定替换次数，如果查找的内容不存在时，将返回原字符串。
   

6. fullmatch

   完全匹配搜索

   方法：re.fullmatch(pattern,string,flags=0)
   返回值：<class ‘_sre.SRE_Match‘>（找到） or None（没找到）
   例如：fm = re.fullmatch(‘sa‘,‘sa‘)
        print(fm.group())
    >>> ‘sa‘
   #该方法与match类似，只不过，该方法搜索的匹配内容必须和搜索的原文一样，否则都认为是未找到。
   

7. subn

   替换并返回元祖

   方法：re.subn(pattern,repl,string,count=0,flags=0)
   返回值：tuple
   例如：print(re.subn(‘as‘,‘3‘,‘sfsasa,sdf‘))    
    >>> (‘sfs3a,sdf‘, 1)
   #该方法把替换后的字符串作为元祖的第一个元素，第二个元素为替换的次数，如果未替换，则次数为0
   

8. finditer

   查找所有并把返回值生成一个迭代器

   方法：re.finditer(pattern,string,flags=0)
   返回值：<class ‘callable_iterator‘>
   例如：f_iter = re.finditer(‘a‘,‘adsfasfa‘)
        find_l = [i.group() for i in f_iter]
        print(find_l)
    >>> [‘a‘, ‘a‘, ‘a‘]
   #利用列表推导式把获取到的结果作为列表进行返回。
   

2. 表达式符号

1. 常用符号如下：

       符号                      表示
   1. ‘.‘              默认匹配除\n之外的任意一个字符，包括字母、数字、中文、特殊字符等，若flags指定为S(DOTALL)，则匹配任意字符，包括换行符。
   2. ‘^‘              默认匹配字符开头，若flags指定为M(MULTILINE)，可以匹配多行中的开头（如：‘^a‘,‘\nabd\nsaf‘）。
   3. ‘$‘              默认匹配字符结尾，若flags指定为M(MULTILINE)，可以匹配多行中的结尾（如：‘$ab‘,‘asdfab\ndsa\n‘）。
   4. ‘*‘              匹配字符0次或多次
   5. ‘+‘              匹配字符1次或多次
   6. ‘?‘              匹配字符0次或1次
   7. ‘{m}‘            匹配字符m次
   8. ‘{n,m}‘          匹配字符n次到m次
   9. ‘|‘              匹配字符二选一
   10. ‘(...)‘         分组匹配
   11. ‘\A‘            匹配字符开头，与‘^‘一样
   12. ‘\Z‘            匹配字符结尾，与‘$‘一样
   13. ‘\d‘            匹配数字[0,9]
   14. ‘\D‘            匹配非数字
   15. ‘\w‘            匹配字母、数字、中文，除特殊字符
   16. ‘\W‘            匹配特殊字符，包括\n
   17. ‘\s‘            匹配空白字符(即‘ ‘)、\t、\n、\r
   18. ‘(?P<name>)‘    分组匹配加命名
   

   第18个表达式符号‘(?P)‘的实例如下：

   s = re.search("(?P<province>\d{2})(?P<city>\d{2})(?P<county>\d{2})(?P<year>\d{4})","371481199306143242")
   print(s.groupdict())
       {‘year‘: ‘1993‘, ‘city‘: ‘14‘, ‘province‘: ‘37‘, ‘county‘: ‘81‘}
   print(s.group())
       3714811993
   print(s.groups()) 
       (‘37‘, ‘14‘, ‘81‘, ‘1993‘)
   #该表达式得到的返回值也是<class ‘_sre.SRE_Match‘>这个类。通过验证的方法也比较多，验证获得的返回值分别为字典、字符串和元祖类型。 
   

2. flags常用的几种关键字参数

   1. re.I(re.IGNORECASE)：忽略大小写
   2. re.M(re.MULTILINE)：多行模式，对‘^‘和‘$‘有所改变
   3. S(DOTALL)：包含\n的匹配模式，主要用于‘.‘的匹配规则
   #括号内为完整输入，前面是简写。
   

   flags关键字参数的实例如下：

   1. re.I

      str1 = ‘\nad23好*sd\n阿道夫dsaf\nsSD‘
      f_i = re.findall(‘s‘,str1,flags=re.I)
      print(f_i)
          [‘s‘, ‘s‘, ‘s‘, ‘S‘]
      #如果flags为默认值（即flags=0），则该返回值中不会有‘S‘该元素。
      

   2. re.M

      str1 = ‘\nad23好*sd\n阿道夫dsaf\nsSD‘
      f_start = re.findall(‘^s‘,str1,flags=re.M)
      print(f_start)
          [‘s‘]
      f_stop = re.findall(‘f‘,str1,flags=re.M)
      print(f_stop)
          [‘f‘]
      #如果flags为默认值（即flags=0），则该返回值应为空列表。
      

   3. re.S

      str1 = ‘\nad23好*sd\n阿道夫dsaf\nsSD‘
      s_any = re.search(‘.‘,str1,flags=re.S)
      print(s_any.group())
      #该打印的结果是空，由于验证时未报错，说明是有匹配到‘\n‘换行符，如果flags为默认值（即flags=0），则上述验证将报错。