正则表达式

正则

• 一些特殊符号及文本组合在一起用来描述或字符串的一些规则称为正则。

• 正则表达式匹配过程

  • 依次拿出表达式和文本中的字符串进行比价

  • 如果每个字符都能匹配，则匹配成功；一旦有匹配不成功的字符，则匹配失败

  • 如果有量词和边界，则匹配过程稍微有些不同

模式	描述
w	匹配字母数字及下划线 ，等价于[A-Za-z0-9_]
W	匹配非字母数字及下划线，等价于[^A-Za-z0-9_]
s	匹配任意空白字符，等价于[ f]
S	匹配任意非空白字符，等价于[^ f]
d	匹配任意数字，[0-9]
D	匹配任意非数字 [^0-9]
A	匹配字符串开始
	匹配字符串结束，如果存在换行，只匹配到换行前的结束字符串
z	匹配字符串结束
G	匹配最后匹配完成的位置
	匹配一个换行符
	匹配一个制表符
^	匹配以字符串的开头，^a 以a开头的字符：abc，ass，a23
$	匹配字符串的末尾，a$以a结尾的：aaa，sca
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，可以匹配包括换行符的任意字符, 要匹配包括 ' ' 在内的任何字符，请使用象 '[. ]' 的模式。
[...]	用来表示一组字符，单独列出：[amk]匹配'a','m'或'k'
[^...]	匹配除去[]中的字符，[^abc]：匹配除去abc以外的字符
*	匹配0个或多个表达式
+	匹配1个或多个表达式
?	匹配0个或1个由前面地正则表达式定义的片段，非贪婪方式
{n}	精确匹配n个前面的表达式
{n,m}	匹配n到m次由前面的正则表达式定义的片段，贪婪方式
a|b	匹配a或b
()	匹配括号内的表达式，也表示一个组

re模块

• re.match(pattern,string,flags=0) 从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话返回None

  • pattern 匹配的正则表达式

  • string 要匹配的字符串

  • flags 标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等。

  • res = re.match()

    • res.group(num) 不给num值默认为0返回整个匹配对应的对象，给值返回对应组号匹配的字符串

    • res.groups() 返回所有小组字符串

• re.search(pattern,string,flags=0) 扫描整个字符串并返回第一个成功的匹配对象。函数和match用法一样

• re.compile(pattern[, flags]) 编译一个正则表达式，生成一个正则表达式（pattern）对象，供match和search使用

• re.findall(pattern[, flags]) 在字符串中查找所有表达式可匹配到的对象（不重复），返回一个列表

• re.finditer(pattern[, flags]) 功能和findall相同，返回值不一样，它返回的是一个迭代器

• re.split(pattern,string, max=0) 根据正则表达式 pattern 中的分隔符把字符 string 分割为一个列表，返回成功匹配的列表，最多分割 max 次(默认是分割所有匹配的地方)

• re.sub(pattern, repl, string, max=0) 把字符串 string 中所有匹配正则表达式 pattern 的地方替换成字符串 repl,如果 max 的值没有给出， 则对所有匹配的地方进行替换

  import re
  regex = re.compile(r'bb(d+)')
  res = re.match(regex,'abb4555@4?bb15')#开头搜索
  print(res.group())
  res = re.search(regex,'abb4555@4?bb15')#全局搜索
  print(res.group())
  res = re.findall(regex,'abb4555@4?bb15')#所有对象
  print(res)
  res = re.sub(regex,'666','abb4555@4?bb15')#替换
  print(res)
  res = re.finditer(regex,'abb4555@4?bb15')#返回迭代器
  print(res)
  
  AttributeError: 'NoneType' object has no attribute 'group'
  bb4555
  ['4555', '15']
  a666@4?666
  <callable_iterator object at 0x0000024B28EBD518>

• • 切割字符串re.split()

    #正常切割
    >>> 'a b  c'.split(' ')
    ['a', 'b', '', 'c']
    
    #正则切割
    >>> import re
    >>> re.split(r's+','a b  c')
    ['a', 'b', 'c']
    
    #加符号试试
    >>> rt = re.split(r'[s+\,:;]+','a,:,; b,c')
    >>> rt
    ['a', 'b', 'c']

  • 分组（）表示要提取的分组

    • ^(d{3})-(d{3,8})$)这里定义了两个组，可以直接从匹配的字符串中提取这两个组

    • 注意到 group(0) 永远是原始字符串， group(1) 、 group(2) ……表示第1、2、……个子串。

      >>> regex = re.compile(r'(d{3})-(d{3-8})$')
      >>> res = re.match(regex,'010-12345678')
      >>> res.group(0)
      '010-12345678'
      >>> res.group(1)
      '010'
      >>> res.group(2)
      '12345678'
      >>> res.groups()
      ('010', '12345678')

  • 贪婪模式和非贪婪模式

    • 贪婪模式是尽可能多的匹配字符串，python默认为贪婪模式，非贪婪模式尽可能少的匹配字符串，在正则表达式后面加个?表示非贪婪模式。例如：字符串abcccb，贪婪模式正则表达式为ab.*c，非贪婪模式的正则表达式为ab.*?c，贪婪模式结果为abccc，非贪婪模式结果为abc，再比如字符串abbb，贪婪模式正则表达式为ab？，非贪婪模式正则表达为ab??，贪婪模式结果为ab，非贪婪结果为a。

      #贪婪模式
      >>> re.match('^(d+)(0*)$','12024200000').groups()
      >>> ('12024200000', '')
      #d+ 把所有的数字匹配完了，0*只能匹配空，把0匹配出来就用非贪婪匹配
      
      #非贪婪模式
      >>> re.match('^(d+?)(0*)$','12024200000').groups()
      ('120242', '00000')

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

  我们来说说什么是标志位：

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

  修饰符	描述
  re.I	使匹配对大小写不敏感
  re.L	做本地化识别（locale-aware）匹配
  re.M	多行匹配，影响 ^ 和 $
  re.S	使 . 匹配包括换行在内的所有字符
  re.U	根据Unicode字符集解析字符。这个标志影响 w, W, , B.
  re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

  import re
  regex = 'abcd'
  res = re.match(r'abcd','ABCD',re.I)
  print(res.group())
  ABCD