正则表达式：内置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,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,flags)

  案例：
  print(re.search("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,flags)

  案例：
  import re
  tt = "This is a gOod girl,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,and so on"
  print(re.split(r"\s+",tt))

  输出：
  [‘This‘,‘is‘,‘a‘,‘gOod‘,‘girl,‘,‘she‘,‘cool,‘and‘,‘so‘,‘on‘]


  案例：
  >>> re.split("[0-9]","abc12efg98sdsd343ksd")
  [‘abc‘,‘‘,‘efg‘,‘sdsd‘,‘ksd‘]
  >>>
  >>> re.split("[0-9]+",‘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,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?",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}",11),match=‘1212‘>
    >>> re.search("[0-9]{2}",9),match=‘12‘>
    >>>

8. {m,n} 匹配前一个字符m至n次，若省略n，则匹配m至无限次

    >>> re.search("[0-9]{2,3}",match=‘121‘>
    >>>
    >>> re.search("[0-9]{4,5}",match=‘1212‘>
    >>>
    >>> re.search("[0-9]{5,6}","hhello#1212")
    >>>
    >>>
    >>> re.search("[0-9]{2,"hhello#12")
    <_sre.SRE_Match object; span=(7,match=‘12‘>
    >>>

    >>> re.search("[0-9]{2,"hhe2w3l3lo#12")
    <_sre.SRE_Match object; span=(11,13),match=‘12‘>
    >>>
    >>>
    >>> re.findall("[0-9]{2,"hhe2w3l3lo#12")
    [‘12‘]
    >>> re.findall("[0-9]{1,"hhe2w3l3lo#12")
    [‘2‘,‘3‘,‘12‘]
    >>>

9. "|"  或。匹配|左右表达式任意一个，从左到右匹配，如果|没有包括在()中，则它的范围是整个正则表达式
    >>> re.search("abc|ABC","hhabce2w3l3lABCo#12")
    <_sre.SRE_Match object; span=(2,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,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,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,"abc\\ss12\sd0\8999\\aas") <_sre.SRE_Match object; span=(3,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]+",flags=re.I).group() ‘abc‘ >>> >>> re.search("[a-z]+","aBc\Css12\sd0\8999\aas",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,match=‘a‘> >>> >>> 点任意匹配模式，改变"."的行为，re.S 解释一下： 1.正则匹配串前加了r就是为了使得里面的特殊符号不用写反斜杠了。 2.[ ]具有去特殊符号的作用,也就是说[(]里的(只是平凡的括号

正则表达式：内置re模块

相关文章