Python基础022--正则表达式

正则表达式模块、贪婪匹配和非贪婪匹配、正则分组、match和search的使用

• 常用的正则表达式元字符

表达式	描述
^	匹配开头
$	匹配结束
.	匹配任意..字符
x?	匹配字符x出现0次或者1次
x+	匹配字符x出现1次或者多次
x*	匹配字符x出现0次或者多次
(xy)+	分组的方式，匹配字符串xy出现1次或者多次
[xy]+	匹配字符x或者y出现了1次或者多次
[0-9]+	匹配一个数字出现了1次或者多次
[a-z]+	匹配一个小写字母出现了1次或者多次
[A-Z]+	匹配一个大写字母出现了1次或者多次
[a-zA-Z]+	匹配一个字母[大小写均可]出现了1次或者多次
x{m,}	匹配字符x出现了m次以上
x{m,n}	匹配字符x出现了m次以上n次以下
$	匹配字符出现了n次以下
...	...
\d	匹配一个数字，和[0-9]相同
\D	匹配一个非数字，和[^0-9]相同
\w	匹配一个字母数字或者下划线，和[a-zA-Z0-9_]相同
\s	匹配一个空白字符
\b	匹配一个字符的边缘位置 hello worhellold : \bhello\b
...	...
*	贪婪匹配符，和其他表达式一起使用
?	懒惰匹配符，和其他表达式一起使用

• 正则表达式re模块常用方法
  • re.match()-->决定re是不是从字符串的的起始位置匹配一个模式；如果不是起始位置匹配成功的话，match()就返回None
    • 函数语法：re.match(pattern,string,flags=0)
      • pattern-->匹配的正则表达式
      • string-->要匹配的字符串
      • flags(可选)-->标识位用于控制正则表达式的匹配方式：是否区分大小写，多行匹配等；
        • re.I--->忽略大小写
        • re.M--->多行模式
        • re.X--->为了增加可读性，忽略空格和#后面的注释
  • 匹配对象的方法
    • group()方法或者返回所有匹配对象或是根据要求返回某个特定子组；groups()返回一个包含唯一或者所有子组的元组；如果正则表达式中没有子组的话，groups()将返回一个空元组，而group()仍然返回全部匹配对象
    • start([group]):用于获取分组匹配的子串在整个字符串中的起始位置，参数默认值为0
    • end([group]):用于获取分组匹配的子串在整个字符串中的结束位置，参数默认值为0
    • span([group]):返回(start([group]),end([group]))

# re.match()使用方法
In [3]: print(re.match('com','comwww.runcomob').group())
com
In [5]: print(re.match('com','www.rencomob'))-->匹配成功，但不是从起始位置匹配，返回None
None
In [6]: print(re.match('com','Comwww.rencomob',re.I|re.M).groups())-->返回子元组，没有子元组返回空元组
()
In [7]: print(re.match('com','Comwww.rencomob',re.I|re.M).group())
Com
In [8]: print(re.match('com','Comwww.rencomob',re.I))
<_sre.SRE_Match object at 0x7f653548bd98>
In [9]: print(re.match('com','Comwww.rencomob',re.I).group())
Com

• re.search()-->扫描整个字符串并返回第一个成功的匹配
  • 函数语法：re.search(pattern,string,flags=0)
  • 参数含义和match一样

# re.search()使用方法
In [10]: print(re.search('www','www.runoog.com').span())    # 在起始位置匹配
(0, 3)
In [11]: print(re.search('com','www.runoog.com').span())    # 不在起始位置匹配
(11, 14)
In [12]: a = '132abc456'
In [13]: print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group())
132abc456
In [14]: print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(1))    # group()可以有参数，确定匹配第几个对象
132
In [15]: print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(2))
abc
In [16]: print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(3))
456
In [17]: print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).groups())    # groups()无参数，返回全部的子组
('132', 'abc', '456')

• re.match()和re.search()的区别

  • re.match()只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，返回None;
  • re.search()匹配整个字符串，直到找到一个匹配；
  • match()和search()是匹配一次，findall()是匹配所有；

• re.compile()-->用于编译正则表达式，生成一个正则表达式对象，供match()和search()这两个函数使用；

  • 语法格式：re.compile(pattern,flags)

In [22]: pattern = re.compile(r'\d+')
In [23]: m = pattern.match('one123twothree34four')
In [24]: print m
None
In [25]: m = pattern.match('one123twothree34four',3,10)
In [26]: print m 
<_sre.SRE_Match object at 0x7f6535575238>
In [27]: m.start()
Out[27]: 3
In [28]: m.end()
Out[28]: 6
In [29]: m.span()
Out[29]: (3, 6)
In [30]: m = pattern.match('one123twothree34four',3,10).group()
In [31]: print m
123

• findall-->在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表；
  • 语法格式：re.findall(pattern,string,flags=0)
  • 一般和compile()连用

In [35]: p = re.compile(r'\d+')
In [36]: res = p.findall('o1n2m3k4')
In [37]: print res
['1', '2', '3', '4']
In [38]: tt = 'Tina is good girl, she is cool, clever, and so on..'
In [40]: rr = re.compile(r'\w*oo\w*')
In [41]: res = rr.findall(tt)
In [42]: print res
['good', 'cool']
In [44]: res = re.findall(r'\w*oo\w*',tt)
In [45]: print res
['good', 'cool']

• re.finditer-->和findall类似，在字符串找到正则表达式所匹配的所有字串，并把他们作为一个迭代器返回；

• re.split-->按照能够匹配的字串将字符串分割后返回列表；

• 贪婪匹配和非贪婪匹配

  • 贪婪匹配-->在整个表达式匹配成功的前提下，尽可能多的匹配-->.*
  • 非贪婪匹配-->在整个表达式匹配成功的前提下，尽可能少的匹配-->.*?

In [49]: s = 'http://www.baidu.com/new.html;http://news.sina.com/music.html'
In [50]: p1 = re.compile(r'http://.+\.html')
In [52]: p1.search(s).group()
Out[52]: 'http://www.baidu.com/new.html;http://news.sina.com/music.html'
In [53]: p2 = re.compile(r'http://.+?\.html')
In [54]: p2.search(s).group()
Out[54]: 'http://www.baidu.com/new.html'

In [55]: data = 'Thu Feb 15 17:46:04 2007::[email protected]:: 2341123-6-8'
In [56]: patt = re.compile(r'.+(\d+-\d-\d)', re.X)
In [57]: print patt.match(data).group()
Thu Feb 15 17:46:04 2007::[email protected]:: 2341123-6-8
In [58]: print patt.match(data).group(1)
3-6-8
In [59]: patt = re.compile(r'.+?(\d+-\d-\d)', re.X)
In [60]: print patt.match(data).group(1)
2341123-6-8

• 正则分组
  • 正则表达式分组-->用一对圆括号()括起来的正则表达式，匹配出的内容就是一个分组；
  • 命名分组-->给具有默认分组编号的组另外再起一个别名；
    • 语法格式：(?P正则表达式) name是一个合法的标识符

# 正则表达式分组
In [64]: s='
更多
dfsl
'
In [66]: print re.search(r'(.*)',s).group(1)
更多
In [67]: print re.search(r'(.*)',s).group()
更多

# 命名分组
In [77]: p = re.compile(r'(?P\b\w+\b)')
In [78]: m = p.search('Lots of punctuation')
In [79]: m.group('word')
Out[79]: 'Lots'
In [80]: m.group()
Out[80]: 'Lots'

URL可以通过named group方式传递指定参数，语法为： (?Ppattern)， name 可以理解为所要传递的参数的名称，pattern代表所要匹配的模式

eg:url(r'^articles/(?P[0-9]{4})/(?P[0-9]{2})/$', views.month_archive)
那么year,month将会对应views传递过来的year,month的值，而后面紧跟的则代表正则表达匹配的模式