关于正则表达式:正则表达式中一些难理解的匹配方式

(?:pattern)

()示意捕捉分组，()会把每个分组里的匹配的值保存起来，从左向右，以分组的左括号为标记，第一个呈现的分组的组号为 1，第二个为 2，以此类推

(?:)示意非捕捉分组，和捕捉分组惟一的区别在于，非捕捉分组匹配的值不会保存起来

import re
a = "123abc456ww"
pattern = "([0-9]*)([a-z]*)([0-9]*)"
print(re.search(pattern,a).group(0,1,2,3))

pattern = "(?:[0-9]*)([a-z]*)([0-9]*)"
print(re.search(pattern,a).group(0,1,2))

能够看到 (?:[0-9]) 匹配的第一个 [0-9] 没有保留下来，即没有保留匹配到的“123”，而 ([0-9]*) 则保留了下来。

python 中 group(0)返回匹配到的整体

(?:pattern)在应用 “ 或 ” 字符 (|) 来组合一个模式的各个局部是很有用。例如，’industr(?:y|ies)’ 就是一个比 ‘industry|industries’ 更简略的表达式。因为咱们独自存储下“y”或者“ies”没有什么意义

a = "British industry"
pattern = "industr(?:y|ies)"
print(re.search(pattern,a).group(0))


pattern = "industr(y|ies)"
print(re.search(pattern,a).group(0, 1))//group(1)会报错，因为没有保留捕捉到的“y”

(?=pattern)

正向必定预查（look ahead positive assert），匹配 pattern 后面的地位。简略说，以 xxx(?=pattern)为例，就是捕捉以 pattern 结尾的内容 xxx

1、这是一个非获取匹配，也就是说, 该匹配不须要获取供当前应用。

industr(?=y|ies) ---> "industr"

2、预查不耗费字符，也就是说，在一个匹配产生后，在最初一次匹配之后立刻开始下一次匹配的搜寻，而不是从蕴含预查的字符之后开始。

(?!pattern)

正向否定预查 (negative assert)， 在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不须要获取供当前应用。

简略说，以 xxx(?!pattern)为例，就是捕捉不以 pattern 结尾的内容 xxx

例如 ”Windows(?!95|98|NT|2000)” 能匹配 ”Windows3.1″ 中的 ”Windows”，但不能匹配 ”Windows2000″ 中的 ”Windows”。预查不耗费字符，也就是说，在一个匹配产生后，在最初一次匹配之后立刻开始下一次匹配的搜寻，而不是从蕴含预查的字符之后开始。

(?<=pattern)

反向 (look behind) 必定预查，与正向必定预查相似，只是方向相同。

简略说，以(?<=pattern)xxx 为例，就是捕捉以 pattern 结尾的内容 xxx。

例如，”(?<=95|98|NT|2000)Windows” 能匹配 ”2000Windows” 中的 ”Windows”，但不能匹配 ”3.1Windows” 中的 ”Windows”。

(?<！pattern)

简略说，以(?<!pattern)xxx 为例，就是捕捉不以 pattern 结尾的内容 xxx。

反向否定预查，与正向否定预查相似，只是方向相同。例如 ”(?<!95|98|NT|2000)Windows” 能匹配 ”3.1Windows” 中的 ”Windows”，但不能匹配 ”2000Windows” 中的 ”Windows”。

贪心匹配和非贪心匹配

var str="abcaxc";
var p=/ab.*c/;// 贪心匹配
str.match(p);//abcaxc
var p2 = /ab.*?c/;  // 非贪心匹配
str.match(p2);//abc

贪心匹配: 正则表达式个别趋向于最大长度匹配，也就是所谓的贪心匹配。如下面应用模式 p 匹配字符串 str，后果就是匹配到：abcaxc(ab.*c)。
非贪心匹配：就是匹配到后果就好，就少的匹配字符。如下面应用模式 p2 匹配字符串 str，后果就是匹配到：abc(ab.*?c)。