正则表达式：内置re模块

正则表达式：
 正则表达式本身是一种小型的，高度专业化的编程语言，在python中，通过内嵌集成re模块
 可以直接调用来实现正则匹配。

 动态的模糊匹配，存在一定的条件

 例1:
 import re
 res = re.match("^Chen", "Chen321RongHua")   #^匹配以Chen开头；
 res1 = re.match("^Chen\d", "Chen321RongHua")  #^匹配以Chen开头，\d其后为数字；
 res2 = re.match("^Chen\d+", "Chen321RongHua")  #^匹配以Chen开头，\d其后为数字， +代表一个或多个；
 print(res.group())
 print(res1.group())
 print(res2.group()) 
 
 输出：
 Chen
 Chen3
 Chen321
 
 
 功能函数：
 1. re.compile()
  编译正则表达式模式，返回一个对象模式；
  可以把那些常用的正则表达式编译成正则表达式对象，提高一点效率；
  
  格式：
  re.complile(pattern, flags=0)
  
  pattern: 编译时用的表达式字符串；
  flags：  编译标志位，用于修正表达式的匹配方式，如：是否区分大小写，多行匹配等。
  
  常用的flags有：
  re.S(DOTALL):   使 . 匹配包括换行在内的所有字符；
  re.I(IgnoreCase):  使匹配对大小写不敏感，即或略大小写
  re.L(Locale):   做本地化识别（local-aware）匹配。
  re.M(Multiline):  多行匹配，影响^和$
  re.X(Verbose):   该标志通过给与更灵活的格式以便将正则表达式写得更易于理解；
  re.U:     根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
  
  
  案例：
   import re
   tt = "This is a good girl, she is cool,clever, and so on....."
   rr = re.compile(r"\w*oo\w*")
   print(rr.findall(tt))
  
   输出：['good', 'cool']
  
   "\w"  匹配包括下划线在内的任何字符: [A-Za-z0-9_]
   "*"   匹配前一个字符0次或多次
  
   import re
   tt = "This is a gOod girl, she is cool,clever, and so on....."
   rr = re.compile(r"\w*oo\w*", re.I)
   print(rr.findall(tt))
   
   输出：['gOod', 'cool']
   
   re.I(IgnoreCase):  使匹配对大小写不敏感，即或略大小写
   
 2. re.match()   
  从字符串的开头开始匹配，返回第一个匹配的；
  
  决定re是否在字符串刚开始的位置匹配，这个方法并不是完全匹配，当pattern结束时
  若string还有剩余字符，仍然视为成功，要想完全匹配，可以在表达式末尾加上边界匹配符号"$"
  
  格式：
  re.match(pattern, string,flags)
 
  案例：
   print(re.match("com", "com www.baidu.com, www.test.Com").group())
   print(re.match("com", "com www.baidu.com", re.I).group())
   print(re.match(".*com", "www.baidu.com, www.test.Com").group())
   
   输出：
   com
   com
   www.baidu.com
   
  一定时要从开头开始起匹配，否则匹配不上
   
   
 3. re.search()   
  
  从字符串的任意位置开始匹配，返回第一个匹配的；
  函数会在字符串内查找模式匹配，只要找到第一个匹配后就返回，如果字符串没有匹配，则返回None
  
  格式：
  re.search(pattern, string,flags)
  
  案例：
  print(re.search("com", "www.baidu.com, www.test.Com").group())
  print(re.search("com", "om www.baidu.Com", re.I).group())
 
  输出：
  com
  Com
 
  备注：
  match和search一旦匹配成功，就是一个match object对象，就以下方法：
  
  group():  返回被re匹配的字符串；
  start():  返回匹配的开始位置；
  end():   返回匹配的结束位置；
  span():   返回一个元组包含开始，结束的位置
  groups():  返回re整体匹配字符串，可以一次输入多个组号，对应的组号匹配的字符串
  
  案例：
  
  tt = "123abc456"
  print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(0))
  print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(1))
  print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(2))
  print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(3))
  
  输出：
  123abc456
  123
  abc
  456

  
 4. re.findall()   
  从字符串的任意位置开始匹配，返回所有匹配的； 没有group方法。
  
  遍历匹配，可以获得字符串中所有的匹配的字符串，返回一个列表
 
  格式：
  re.findall(pattern, string,flags)
 
  案例：
  import re
  tt = "This is a gOod girl, she is cool,clever, and so on....."
  rr = re.compile(r"\w*oo\w*", re.I)
  print(rr.findall(tt))
 
  输出：
  ['gOod', 'cool']
 
 5. re.split()
  按照能够匹配的字符串将string分割后返回列表；
  
  格式：
  re.split(pattern,string[,maxsplit])
  maxsplit 用于指定最大的分割次数，不指定全部分割
  
  
  例如：
  re.split(r"\S+", string)    将字符串按照空格分割一个单词列表
  
  
  tt = "This is a gOod girl, she is cool,clever, and so on"
  print(re.split(r"\s+", tt))
  
  输出：
  ['This', 'is', 'a', 'gOod', 'girl,', 'she', 'is', 'cool,clever,', 'and', 'so', 'on']
  
  
  案例：
  >>> re.split("[0-9]", "abc12efg98sdsd343ksd")
  ['abc', '', 'efg', '', 'sdsd', '', '', 'ksd']
  >>>
  >>> re.split("[0-9]+", "abc12efg98sdsd343ksd")
  ['abc', 'efg', 'sdsd', 'ksd']
  >>>
  
  expr = "3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)"
  >>> re.split(r"\(([^()]+)\)", expr,1)
  ['3*', ' 4+ 50 ', '-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)']
 
 6. re.sub():
    使用re替换string中每一个匹配的字符串后返回匹配的字符串
  
  格式：
  
  re.sub(pattern, string, count)
  
  案例：
  >>> re.sub("[0-9]+", "|", "abc12ded87sds40hsd")
  'abc|ded|sds|hsd'
  >>>
  
  >>> re.sub("[0-9]+", "|", "abc12ded87sds40hsd", count=2)  #count表示需要替换的个数，不写表示替换所有
  'abc|ded|sds40hsd'
  >>>
 
 
 
 
 常规的正则表达式符号： 
 1. "."   匹配任意除换行符"\n"外的字符(在DOTALL模式中也能匹配换行符);
    >>> re.search("R.+Hua", "Chen321RongHua123").group()
    'RongHua'
    >>> re.search("R[a-zA-Z]+a", "Chen321RongHua123").group()
    'RongHua'
    >>>
    >>> re.search("R[a-zA-Z]+a", "Chen321RongHua123RongHua").group()
    'RongHua'
    
    [0-9]   #表示任何数字
    [a-z]   #表示匹配任意小写字母；
    [A-Z]   #表示匹配任意大写字母；
    [a-zA-Z]  #表示匹配任意大小写字母；
   
 2. "^"  匹配字符串开头, 在多行模式中匹配每一行的开头;
 3. "$"  匹配字符串末尾，在多行模式中匹配每一行的末尾
 4. "*"  匹配前一个字符0次或多次
    >>> re.search("hhh*", "hhello#1212")     #至少匹配”hh"
    <_sre.SRE_Match object; span=(0, 2), match='hh'>
    >>> 
 5. "+"  匹配前一个字符1次或无限次
 6. "?"  匹配前一个字符0次或1次
    >>> re.search("hhh?", "hhello#1212")     #至少匹配”hh"
    <_sre.SRE_Match object; span=(0, 2), match='hh'>
    >>>

 7. "{m}" 匹配前一个字符m次，
    >>> re.search("l{2}", "hhello#1212")
    <_sre.SRE_Match object; span=(3, 5), match='ll'>
    
    >>> re.search("[0-9]{3}", "hhello#1212")
    <_sre.SRE_Match object; span=(7, 10), match='121'>
    >>>
    >>> re.search("[0-9]{4}", "hhello#1212")
    <_sre.SRE_Match object; span=(7, 11), match='1212'>
    >>> re.search("[0-9]{2}", "hhello#1212")
    <_sre.SRE_Match object; span=(7, 9), match='12'>
    >>>
       
 8. {m,n} 匹配前一个字符m至n次，若省略n，则匹配m至无限次
 
    >>> re.search("[0-9]{2,3}", "hhello#1212")
    <_sre.SRE_Match object; span=(7, 10), match='121'>
    >>>
    >>> re.search("[0-9]{4,5}", "hhello#1212")
    <_sre.SRE_Match object; span=(7, 11), match='1212'>
    >>>
    >>> re.search("[0-9]{5,6}", "hhello#1212")
    >>>
    >>>
    >>> re.search("[0-9]{2,3}", "hhello#12")
    <_sre.SRE_Match object; span=(7, 9), match='12'>
    >>>
 
    >>> re.search("[0-9]{2,3}", "hhe2w3l3lo#12")
    <_sre.SRE_Match object; span=(11, 13), match='12'>
    >>>
    >>>
    >>> re.findall("[0-9]{2,3}", "hhe2w3l3lo#12")
    ['12']
    >>> re.findall("[0-9]{1,3}", "hhe2w3l3lo#12")
    ['2', '3', '3', '12']
    >>>
 
 9. "|"  或。匹配|左右表达式任意一个，从左到右匹配，如果|没有包括在()中，则它的范围是整个正则表达式
    >>> re.search("abc|ABC", "hhabce2w3l3lABCo#12")
    <_sre.SRE_Match object; span=(2, 5), match='abc'>
    >>>
    >>> re.findall("abc|ABC", "hhabce2w3l3lABCo#12")
    ['abc', 'ABC']
    >>>
    
 10. "(...)" 分组匹配。
    >>> re.search("(abc){2}", "hhabcabc2w3l3lABCo#12abc")    #匹配字符串abc的匹配次数
    <_sre.SRE_Match object; span=(2, 8), match='abcabc'>
    
    >>> re.search("abc{2}", "hhabcabcccccabc2w3l3lABCo#12abc")   #只是匹配c匹配次数
    <_sre.SRE_Match object; span=(5, 9), match='abcc'>
    
    >>> re.search("(\|\|){2}", "hhabcabc2w3l3lABCo#12||||abc||")
    <_sre.SRE_Match object; span=(21, 25), match='||||'>
 
 11. "\"  转义字符，使后一个字符改变原来的意思
 
  "\A"  只匹配字符串开头,  同^
  "\Z"  只匹配字符串结尾，  同$
      >>> re.search("\Ahh.+||\Z", "hhabcabc2w3l3lABCo#12||abc||")
      <_sre.SRE_Match object; span=(0, 28), match='hhabcabc2w3l3lABCo#12||abc||'>
  "\d"  匹配数字:       [0-9]
  "\D"  匹配非数字:      [^0-9]    
  "\w"  匹配包括下划线在内的任何字符: [A-Za-z0-9_]
  "\W"  匹配非字母字符，即匹配特殊字符 [^A-Za-z0-9_]
  "\s"  匹配任何空白字符：    <空格>\t,\n,\r,\f,\v
  "\S"  匹配非空白字符：    [^\s]
 
 
 
 
 12. 正则表达式中中括号中可以表示
  1. 某个区间内 如 [a-zA-Z0-9]
  2. 某几个的范围 [abcd]
  3. 可以在中括号中进行取非的操作. [^a]
  4. 在中括号中的字符不再有特殊的含义  如经常匹配全部的 .和*  [.][*]
 
 

 
  >>> re.search("(?P<id>[0-9])","abcd1212sdsd121#we")
  <_sre.SRE_Match object; span=(4, 5), match='1'>
  >>>
  >>> re.search("(?P<id>[0-9])","abcd1212sdsd121#we").group()
  '1'
  >>> re.search("(?P<id>[0-9]+)","abcd1212sdsd121#we").group()
  '1212'
  >>> re.search("(?P<id>[0-9]+)","abcd1212sdsd121#we").groupdict()
  {'id': '1212'}
  >>>
  >>> re.search("(?P<id>[0-9]+(?P<name>[a-zA-Z]+))","abcd1212sdsd121#we").groupdict()
  {'id': '1212sdsd', 'name': 'sdsd'}
  >>>
  >>> re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birth>[0-9]{8})", "362822198509160042").groupdict()
  {'province': '3628', 'city': '22', 'birth': '19850916'}
  >>>
  

  
 匹配\： （需要用r且加\转义）

  >>> re.search(r"\\", "abc\ss12\sd0\8999\aas")
  <_sre.SRE_Match object; span=(3, 4), match='\\'>
  >>>
  >>>
  >>> re.search(r"\\", "abc\ss12\sd0\8999\\aas")
  <_sre.SRE_Match object; span=(3, 4), match='\\'>
  >>>
  >>>
  >>> re.search(r"\\", "abc\\ss12\sd0\8999\\aas")
  <_sre.SRE_Match object; span=(3, 4), match='\\'>
  >>>
  
 
 匹配忽略大小写：（flags = re.I） 
  >>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I)
  <_sre.SRE_Match object; span=(0, 3), match='abc'>
  >>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I).group()
  'abc'
  >>>
  >>> re.search("[a-z]+", "aBc\Css12\sd0\8999\aas", flags=re.I)
  <_sre.SRE_Match object; span=(0, 3), match='aBc'>
  >>>
  
 
 匹配多行模式：（re.M），改变"^"和"$"的行为；
  >>> re.search(r"^a", "\nabc\neeee")
  >>>
  >>>
  >>> re.search(r"^a", "\nabc\neeee",flags=re.M)
  <_sre.SRE_Match object; span=(1, 2), match='a'>
  >>>
  >>> 
  
 点任意匹配模式，改变"."的行为，re.S
 
 
解释一下：
1.正则匹配串前加了r就是为了使得里面的特殊符号不用写反斜杠了。
2.[ ]具有去特殊符号的作用,也就是说[(]里的(只是平凡的括号

转载于:https://www.cnblogs.com/brace2011/p/9226384.html