python re模块匹配时贪婪和非贪婪模式

python贪婪和非贪婪

　　正则表达式通常用于在文本中查找匹配的字符串。正则表达式模式中使用到通配字，当它在从左到右的顺序求值时，会尽量“抓取”满足匹配最长字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪

贪婪

默认情况下，正则表达式将进行贪婪匹配。所谓“贪婪”，其实就是在多种长度的匹配字符串中，选择较长的那一个。例如，如下正则表达式本意是选出人物所说的话，但是却由于“贪婪”特性，出现了匹配不当：

>>> sentence = """You said "why?" and I say "I don't know"."""
>>> re.findall(r'"(.*)"', sentence)
['why?" and I say "I don\'t know']

非贪婪

当我们期望正则表达式“非贪婪”地进行匹配时，需要通过语法明确说明： 

      {2,5}?    捕获2-5次，但是优先次数少的匹配

在这里，问号?可能会有些让人犯晕，因为之前他已经有了自己的含义：前面的匹配出现0次或1次。其实，只要记住，当问号出现在表现不定次数的正则表达式部分之后时，就表示非贪婪匹配。 

非贪婪例子：

>>> sentence = """You said "why?" and I say "I don't know"."""
>>> re.findall(r'"(.*?)"', sentence)
['why?', "I don't know"]

>>> re.findall('hi*?', 'hiiiii')
['h']
>>> re.findall('hi{2,}?', 'hiiiii')
['hii']
>>> re.findall('hi{1,3}?', 'hiiiii')
['hi']

例子：

import re

content = 'Hello 1234567 World_This is a Demo'
result = re.match('^He.*(\d+).*Demo$', content)
print(result)
print(result.group(1))

运行结果：

<_sre.SRE_Match object; span=(0, 35), match='Hello 1234567 World_This is a Regex Demo'>
7

贪婪匹配下，.*会匹配尽可能多的字符，我们的正则表达式中.*后面是\d+，也就是至少一个数字，并没有指定具体多少个数字，所以.*就尽可能匹配多的字符，所以它把123456也匹配了，给\d+留下一个可满足条件的数字7，所以\d+得到的内容就只有数字7了。

import re

content = 'Hello 1234567 World_This is a Demo'
result = re.match('^He.*?(\d+).*Demo$', content)
print(result)
print(result.group(1)) 

运行结果：

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567

贪婪匹配是尽可能匹配多的字符 .*? 之后是 \d+ 用来匹配数字，当 .*? 匹配到 Hello 后面的空白字符的时候，再往后的字符就是数字了，而 \d+ 恰好可以匹配，那么这里 .*? 就不再进行匹配，交给 \d+ 去匹配后面的数字。所以这样， .*? 匹配了尽可能少的字符， \d+ 的结果就是 1234567 了

>>> re.match(r"aa(\d+)","aa2343ddd").group(1)
'2343'
>>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
'2'
>>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1) 
'2343'
>>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
'2343'

捕获与非贪婪

严格来说，这一部分并不是非贪婪特性。但是由于其行为与非贪婪类似，所以为了方便记忆，就将其放在一起了。 

      (?=abc) 捕获，但不消耗字符，且匹配abc

      (?!abc) 捕获，不消耗，且不匹配abc

在正则表达式匹配的过程中，其实存在“消耗字符”的过程，也就是说，一旦一个字符在匹配过程中被检索（消耗）过，后面的匹配就不会再检索这一字符了。 

例子：

想找出字符串中出现过1次以上的单词

>>> sentence = "Oh what a day, what a lovely day!"
>>> re.findall(r'\b(\w+)\b.*\b\1\b', sentence)
['what']

在第一个(\w+)匹配到what，并且其后的\1也匹配到第二个what的时候，“Oh what a day, what”这一段子串都已经被正则表达式消耗了，所以之后的匹配，将直接从第二个what之后开始。自然地，这里只能找出一个出现了两次的单词。 

那么解决方案，就和上面提到的(?=abc)语法相关了。这样的语法可以在分组匹配的同时，不消耗字符串！所以，正确的书写方式应该是：

>>> re.findall(r'\b(\w+)\b(?=.*\b\1\b)', sentence)
['what', 'a', 'day']

如果我们需要匹配一个至少包含两个不同字母的单词，则可以使用(?!abc)的语法：

>>> re.search(r'([a-z]).*(?!\1)[a-z]', 'aa', re.IGNORECASE)
>>> re.search(r'([a-z]).*(?!\1)[a-z]', 'ab', re.IGNORECASE)
<_sre.SRE_Match object; span=(0, 2), match='ab'>

补充：

一、 \1   \2

([a-z])([a-z])\2\1 

则可以匹配字符串abba 第一个圆括号内的正则匹配字符a，则在字符串最后\1这个位置必须是字符a,第二个括号匹配字符b,在倒数第二个位置\2必须是字符b 如果有嵌套的圆括号，顺序是按左括号的次序计算的

二、\b

\b 称为单词边界（word boundary）符,例如只想匹配 My cat is bad.中的cat 可以使用 \bcat\b

#re.I要在compile的时候指定,注意\b在python中是回退符，正则模式之前一定要加r(raw string)

p = re.compile(r'\bcat\b', re.I)

三、python字符串前面加u,r,b的含义

    u/U:表示unicode字符串 

    r/R:非转义的原始字符串 ，而如果是以r开头，那么说明后面的字符，都是普通的字符了，即如果是“\n”那么表示一个反斜杠字符，一个字母n，而不是表示换行了。以r开头的字符，常用于正则表达式，对应着re模块。

    b:bytes 

        python3.x里默认的str是(py2.x里的)unicode, bytes是(py2.x)的str, b”“前缀代表的就是bytes 
        python2.x里, b前缀没什么具体意义， 只是为了兼容python3.x的这种写法