Python 正则表达式使用--Re 模块详解

记号	说明	示范
普通字符串	就匹配该字符串的值	abc,123,A_B_2
re1\|re2	匹配正则表达式 re1 或者 re2	abc\|123，就是 abc 或者 123
.	匹配除了换行符之外的任何字符	a.b，意味着可以是abb,acb,a2b 等待
^	匹配字符串的开始	^abc，可以是abcd,abce，但是不能是babc
$	匹配字符串的结尾	ab$，可以是ab，cab,2ab, 但是不能是abc
*	匹配前面出现的正则表达式零次或者多次，该正则表达式可以是单个字符，也可以是()包起来的	a，可以是aaaaa，或者空字符 (abc)，可以是abcabcabc，或者空字符
+	匹配前面出现的正则表达式1次或者多次，该正则表达式可以是单个字符，也可以是()包起来的	a+，可以是aaaaa，或者a (abc)+，可以是abcabcabc，或者abc
?	匹配前面出现的正则表达式零次或者1次，该正则表达式可以是单个字符，也可以是()包起来的	a?，可以是a，或者空字符 (abc)?，可以是abc，或者空字符
{N}	匹配前面出现的正则表达式 N 次	a{4}，即aaaa
{M,N}	匹配前面出现的正则表达式 M 到 N 次	a{2,4}，即aa，aaa，aaaa
[....]	匹配字符组中出现的任何一个字符	[abc] ，即匹配a、b、c
[..X-Y....]	匹配从字符 X 到 Y 的任意字符	[0-3]，即匹配0、1、2、3
[^....]	即不匹配此字符集中出现的任何一个字符	[^0-3]，即匹配除了 0、1、2、3之外的所有字符
(*\|+\|?\|{})?	用于上面出现的任何“非贪婪”。版本重复匹配次数符号。	这个需要在讲贪婪模式的时候详细讲。
(....)	匹配封闭括号中正则表达式，并且保存在子组	在讲 re.search/match 等具体函数时候可以详细的讲。

以上都是正则表达式最最常用的，如果对上面不熟悉，后面的章节可以不看了。

正则表达式-特殊字符

记号	示范	示范
\d	匹配任何数字，等同于[0-9]，（ \D 是 \d 的反义：非任何数字）	abc\de，可以是abc0e、abc1e、abc2e 等
\w	匹配任何数字字母字符，等同于[0-9a-zA-Z]，（ \W 是 \w 的反义：非任何数字字母字符）	_\w，即_0..._9，_a..._z，_A..._Z 都可以
\s	匹配任何空白符号，等同于[\n\r\t\v\f]，（\S 是 \s 的反义字符）	ab\sc，可以是"ab c"
\b	匹配单词边界，（\B 是 \b 的反义字符）	\bThe\b 意味着The，但是不能是 The 开头的字符串
\nn	匹配已经保存的子组（需要和(.....)一起使用）	在讲 re.search/match 等具体函数时候可以详细的讲。
\c	逐一匹配特殊字符c（即，取消它的特殊含义，按照字面上匹配）	如\.，即匹配字符. 如 \\，即匹配字符\
\A	匹配字符串的起始	\Aabc
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串	abc\Z

2. Re 模块：核心函数和方法

2.1 re.compile() 编译函数

re.compile 对正则表达式模式 pattern 进行编译，编译后的结果可以用于 re.search、re.match、re.findall 等函数，它并不是必须的，但是它非常有用！

为什么说不是必须的呢，请看下面的一段代码。可以看出，无论是直接用正则表达式还是编译后再使用，都可以得到一样的结果。

a="abc"
patt="^ab"
res=re.match(patt,a)
print(res.group())
patt=re.compile("^ab")
res=re.match(patt,a)
print(res.group())

那为什么还要有 re.compile() 这个函数呢，因为性能！

Python 的代码终究会被编译成字节码，然后才会被解释器执行，如果使用预编译代码会比使用字符串要快，并且我们处理文档时候，往往是一个正则表达式要用很多次，如果直接使用字符串，那么每次都需要重复编译，而直接采用预编译，然后调用预编译结果，则可以快很多。同一个正则表达式被使用得越多越划算。

希望大家养成这个良好的编程习惯！即使模块函数可能对已经编译的对象进行缓存，还是会节省了查询缓存和使用相同字符串反复调用函数的性能开销。

2.1.1 re.compile() 语法格式

re.compile(pattern, flags=0)

pattern 即第一章中提到的正则表达式，flags是可选的，默认为 0。flags 的可选值如下：

.re.I (re.IGNORECASE): 忽略大小写
.re.M (MULTILINE): 多行模式，改变'^'和'$'的行为
.re.S (DOTALL): 点任意匹配模式，改变'.'的行为
.re.L (LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
.re.U (UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
.re.X (VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入

上述 flag 可以单独用，也可以一起使用。

2.1.2 re.compile() 用法

在上一个代码段中就已经显示了，后续也会反复使用，此处不再赘述。

2.2 re.match() 和 re.search() 匹配和搜索函数

2.2.1 re.match() 语法格式

re.match(pattern, string, flags=0)

flags 和 re.compile() 中的 flags 用法一致。

string 即被匹配的字符串。

2.2.2 re.match() 用法

用一小段代码来演示，match 是从字符串的开始进行匹配的。

#匹配全体Python整型的字符串表示形式的集合
patt=re.compile("^[0-9]+$")
words=["1","23","09","www.XXX.net",\
       "8.0","a2","_d3234","cd"]
for word in words:
    if(re.match(patt,word)):
        print(word)

2.2.3 re.search() 语法格式

re.search(pattern, string, flags=0)

flags 和 re.compile() 中的 flags 用法一致。

string 即被匹配的字符串。

2.2.4 re.search() 用法

请注意，search 只找到第一个符合条件字符串的就返回了，所以即使被搜索的字符串中还有其他的符合字符串，也被忽略了。

请注意，此处 match 也好，search 也好，都是返回的一个对象，这个对象有方法 group()，groups()，如果没有找到的时候，返回的是 None 对象。

group() 方法或者返回所有匹配对象，或者是根据特定要求返回某个特定子组。

groups() 方法很简单，它返回一个包含唯一或者所有子组的元组，如果正则表达式中没有子组的话，groups() 将返回一个空元组，而 group() 则仍然返回全部匹配对象。

下面是一个没有子组的代码（没有使用()来划分子组）。

# 找出字符串中中包含的 ab 字符串，不区分大小
a="S abc ABC -sfg- dfghdfh abc AB A ABCD ED BA ab Ab aB sgwet"
patt=re.compile("AB",re.I)
res=re.search(patt,a)
print(res.group()) #请注意，此处只找到第一个符合条件的就返回了
print(res.groups())

这是一个有子组的代码，使用了 ()，可以看到 group() 返回了全部匹配对象，而 groups() 则返回各自的子组。

# 找出字符串中中包含的 abcde 字符串，不区分大小
a="S abc ABC -sfg- dfghdfh abc AB A ABCDE ED BA ab Ab aB sgwet"
patt=re.compile("(AB)c(DE)",re.I)
res=re.search(patt,a)
print(res.group()) #请注意，此处只找到第一个符合条件的就返回了
print(res.groups())

另外，返回对象中可能有用的 .start() 和 .end() 方法，返回匹配对象起始地址和截止地址。

words=["abcom"]
patt=re.compile("^abcom")
for word in words:
    res=re.search(patt,word)
    if(res is not None):
        print(res) # 返回的是一个 re.Match 对象
        print(res.group()) # 返回全部匹配对象
        print(res.groups()) # 返回子组，如果有的话，没有则返回空()
        print(res.start()) #返回匹配对象起始地址
        print(res.end()) #返回匹配对象截至地址

2.3 re.findall() 和 re.finditer() 查找所有符合条件的字符串

2.3.1 re.findall() 语法格式

    re.findall(pattern, string, flags=0)
    flags 和 re.compile() 中的 flags 用法一致。
    string 即被匹配的字符串。

2.3.2 re.findall() 用法

re.findall 可以查找出所有的符合要求的字符串，并且返回一个列表。

下面这段代码描述了四种常见的情况。

# 找出字符串中中包含的 abcde 字符串，不区分大小
a="S abc ABC -sfg- dfghdfh abc AB A ABCDE ED BABcdedf ab Ab aB sgwet"
#没有子组
patt=re.compile("ABcDE",re.I)
res=re.findall(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是列表。
# 因为没有子组，返回的是全部对象的列表
print(res)  

#此处有子组
patt=re.compile("(AB)c(DE)",re.I)
res=re.findall(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是列表。
# 因为有子组，返回的包含子组元组的列表，而不是全部对象的列表
print(res)  

#此处有子组，并且把整个字符串用()包括起来了
patt=re.compile("((AB)c(DE))",re.I)
res=re.findall(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是列表。
# 因为有子组，且把整个字符串用()包括起来了
#所以返回的包含全部匹配对象、各个子组元组的列表，而不是全部对象的列表
print(res)  


#此处有子组，子组里面还有子组，并且把整个字符串用()包括起来了
patt=re.compile("((A(B))c(DE))",re.I)
res=re.findall(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是列表。
# 因为有子组，且把整个字符串用()包括起来了
#所以返回的包含全部匹配对象、各个子组元组的列表，而不是全部对象的列表
print(res)

2.3.3 re.finditer() 语法格式

re.finditer(pattern, string, flags=0)
flags 和 re.compile() 中的 flags 用法一致。
string 即被匹配的字符串。

re.finditer() 和 re.findall() 非常相似，只不过返回的是一个迭代器，而不是列表，对于每个匹配返回一个匹配对象(re.match 匹配对象)。所以读取方式有了变化，这样内存会更加友好。

2.3.4 re.finditer() 用法

将 re.findall 函数的用法处代码稍微改一下。

# 找出字符串中中包含的 abcde 字符串，不区分大小
a="S abc ABC -sfg- dfghdfh abc AB A ABCDE ED BABcdedf ab Ab aB sgwet"
#没有子组
patt=re.compile("ABcDE",re.I)
res=re.finditer(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是列表。
# 因为没有子组，返回的是全部对象的迭代器
print("*"*28)
for tmp in res:
    print(tmp)
    print(tmp.group())
    print(tmp.groups())

#此处有子组
patt=re.compile("(AB)c(DE)",re.I)
res=re.finditer(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是迭代器。
# 因为有子组，返回的包含子组元组的迭代器，而不是全部对象的迭代器
print("*"*28)
for tmp in res:
    print(tmp)
    print(tmp.group())
    print(tmp.groups())

#此处有子组，并且把整个字符串用()包括起来了
patt=re.compile("((AB)c(DE))",re.I)
res=re.finditer(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是迭代器。
# 因为有子组，且把整个字符串用()包括起来了
#所以返回的包含全部匹配对象、各个子组元组的迭代器，而不是全部对象的迭代器
print("*"*28)
for tmp in res:
    print(tmp)
    print(tmp.group())
    print(tmp.groups())


#此处有子组，子组里面还有子组，并且把整个字符串用()包括起来了
patt=re.compile("((A(B))c(DE))",re.I)
res=re.finditer(patt,a)
# 请注意，此处没有 group()、groups() 对象，因为返回的是迭代器。
# 因为有子组，且把整个字符串用()包括起来了
#所以返回的包含全部匹配对象、各个子组元组的迭代器，而不是全部对象的迭代器
print("*"*28)
for tmp in res:
    print(tmp)  
    print(tmp.group())
    print(tmp.groups())

2.4 re.split() 分割函数

大家肯定用过 str.split()， re.split()功能更加强大，因为它被设计出来时候就是可以使用正则表达式的。

2.4.1 re.split() 语法结构

re.split(pattern, string, maxsplit=0, flags=0)

flags 和 re.compile() 中的 flags 用法一致。
string 即被匹配的字符串。

maxsplit 是最多能被分割的次数，从左而右计算。

re.split() 返回一个列表。

2.4.2 re.split() 用法

可以看到下面这段代码，虽然剩下的代码还可以分割，但是因为限制了分割的次数，也不再分割。

a="das:fgfd:dfdgf:dadf"
res=re.split(":",a,2)
res

2.5 re.sub() 和 re.subn() 替换函数

2.5.1 re.sub() 语法结构

re.sub(pattern, repl, string, count=0, flags=0)

flags 和 re.compile() 中的 flags 用法一致。

repl 即用来替换的字符串

string 即被替换的字符串。

count 即被替换的次数，为 0 时候意味着全部替换。

re.sub(）返回被替换后的字符串

2.5.2 re.sub() 用法

# 找出字符串中中包含的 ab 字符串，不区分大小,并且用 XY 来替换
a="S abc ABC -sfg- dfghdfh abc AB A ABCDE ED BABcdedf ab Ab aB sgwet"
#没有子组
patt=re.compile("AB",re.I)
res=re.sub(patt,"XY",a)
# 请注意，此处返回的是字符串
print(res)

2.5.3 re.subn() 语法结构

re.subn(pattern, repl, string, count=0, flags=0)

flags 和 re.compile() 中的 flags 用法一致。

repl 即用来替换的字符串

string 即被替换的字符串。

count 即被替换的次数，为 0 时候意味着全部替换。

re.sub(）返回一个元组，第一个元素是被替换后的字符串，第二个元素是被替换次数的数值。

2.5.4 re.subn() 用法

# 找出字符串中中包含的 ab 字符串，不区分大小,并且用 XY 来替换
a="S abc ABC -sfg- dfghdfh abc AB A ABCDE ED BABcdedf ab Ab aB sgwet"
#没有子组
patt=re.compile("AB",re.I)
res=re.subn(patt,"XY",a)
# 请注意，此处返回的是字符串和替换次数的列表
print(res)

3. 贪婪模式和非贪婪模式

给大家看下面一小段代码，想在一串字符串中找出连续的数字字符,1 个或者多个都可以。结果是找出了最长的那个符合要求的。这就是贪心匹配，也叫贪婪模式，Python 中默认的模式，在从左到右的顺序中求值时候，尽可能的抓取满足匹配的最长的字符。

在使用 "*"，"+"，或者"？" 取长度不确定的字符串时候，都会遇到这种情况。

# 找出连续的数字字符,1 个或者多个
a="0123456789"
patt=re.compile("\d+") 
res=re.search(patt,a)
# 请注意，此处返回的是匹配对象
print(res)
print(res.group())
print(res.groups())

如果不想要贪婪模式，只要最短的满足条件的字符串，可以在"*"，"+"，或者"？" 后面使用 “？” 来使用非贪婪模式。

4. 扩展表示法

4.1 (?iLmsux) 在正则表达式中嵌入一个或者多个特殊"标记"参数

之前在说re.compile 、re.match、re.search 等函数，提到了模型 pattern 里面配套使用的 flags。其实，除了re.compile 、re.match、re.search 函数中使用 flags 选项，还可以直接在正则表达式中使用类似的功能，即扩展表达式。常见的有（?iLmsux），下面会一一慢慢说。

首先请注意， (?iLmsux) 只能在正则表达式的开头使用；并且 (?imx) 正则表达式包含三种可选标志：i, m, 或 x ，只影响括号中的区域；(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

4.1.1 (?i)

首先，(?i) 表示 re.I/IGNORECASE，忽略大小写；

words=["abcom","abco","abCoMD","ABCOM","BDAbcOM"]
#patt=re.compile("(?iabcom)")
for word in words:
    res=re.search(r"(?i)abcom",word)
    if(res is not None):
        print("*"*20)
        print(word)
        print(res.group())
        print(res.groups())

4.1.2 (?L)

等同re.l，re.LOCALE，表示字符集本地化。即使预定字符类 \w \W \b \B \s \S 取决于当前区域设定。

这个功能是为了支持多语言版本的字符集使用环境的，比如在转义符\w，在英文环境下，它代表[a-zA-Z0-9_]，即所以英文字符和数字。如果在一个法语环境下使用，缺省设置下，不能匹配"é" 或 “ç”。加上这L选项和就可以匹配了。不过这个不适用于中文环境，将会在第五小节讲如何匹配中文字符。

4.1.3 (?m)

等同于 re.M ，即多行模式；

word='''
This line is the first abcom,
another line ABCOM,
that line, it's the bestABcomm
'''

res=re.findall(r"(?im)(^th[\w\s]+)",word)
if(res is not None):
    print(res)

4.1.4 (?s)

表示符号 . 可以代表任意符号（正常情况符号 . 表示除 \n 之外的任意符号）；等同于.re.S (DOTALL)。用下面的代码，就可以清晰的看出使用 (?s) 和不使用直接的差异了。

word='''
This line is the first abcom,
another line ABCOM,
that line, it's the bestABcomm
'''

res=re.findall(r"(?is)(th.*)",word)
if(res is not None):
    print(res)
res=re.findall(r"(?i)(th.*)",word)
if(res is not None):
    print(res)

4.1.5 (?u)

等同re.U，re.UNICODE，使用 \w, \W, \b, \B 这些元字符时将按照 UNICODE 定义的属性.

4.1.6 (?x)

等同于 re.X ，冗长模式，允许编写更友好的正则表达式。

4.2 (?:...) 表示一个匹配不用保存的分组

用下面这段代码来看，当使用 re.search 函数时候，如果使用了 (?:...) 语法，那么返回的对象使用 .groups() 方法时候，则不会体现那个子组。

word="I am happy now, let's have a happy day! If you are not happy, please do not tell me!"

res = re.search(r'(?:happy)\s\w{3,4}', word)
if(res is not None):
    print("*"*40)
    print(res)
    print(res.group())
    print(res.groups())
    print(res.groups(1))
    
res = re.search(r'(happy)\s\w{3,4}', word)
if(res is not None):
    print("*"*40)
    print(res)
    print(res.group())
    print(res.groups())
    print(res.groups(1))

再看一个复杂一点的例子

当不使用 (?:) 时候

word="I am happy now! let's have a happy day! "
    
res = re.search(r'((?:happy)\s(\w+))!', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    #显示第二个()包括的对象，越过了(?:)分组，直接到(\w+)
    print("res.group(2)",res.group(2)) 
    #虽然有第三个()，但是因为(?:)分组不保存，所以实际只有两个分组
    print("res.group(3)",res.group(3)) 
    print("res.group(4)",res.group(4)) #这一行其实执行不到

但是使用了(?:)后，子组少了一个

word="I am happy now! let's have a happy day! "
    
res = re.search(r'((?:happy)\s(\w+))!', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    #显示第二个()包括的对象，越过了(?:)分组，直接到(\w+)
    print("res.group(2)",res.group(2)) 
    #虽然有第三个()，但是因为(?:)分组不保存，所以实际只有两个分组
    print("res.group(3)",res.group(3)) 
    print("res.group(4)",res.group(4)) #这一行其实执行不到

4.3 (?P<name>...) 由名字 name 标示而不是数字 ID 表示的正则分组

4.3.1 使用数字 ID 表示分组

一般我们可以用数字来表示各种分组。如下：

word="I am happy now! let's have a happy day! "
    
res = re.search(r'((happy)\s(\w+))!', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    print("res.group(3)",res.group(3)) #显示第三个()包括的对象
    print("res.group(4)",res.group(4)) #因为没有第四个()，所以会报错

使用数字 ID 表示分组的规律如下：

分组组从 0 开始编号
分组 0 始终存在，表示整个正则表达式的匹配对象
匹配对象方法.groups() 以 0 为默认参数，等同于. group()
分组从左到右 从 1 向上编号，分组也可以嵌套，第 n 个 ( 对应的就是第 n 个分组。

4.3.2 使用名字 name 表示分组

我们还可以用(?P<name>...) 来取代数字ID。

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?P<NAME>happy)\s(\w+)!)', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    print("res.group(3)",res.group(3)) #显示第三个()包括的对象
    #显示 NAME 表示的对象，即和 res.group(2) 的结果为同一个
    print("res.group('NAME')",res.group('NAME')) 
    print("res.group(4)",res.group(4)) #因为没有第四个()，所以会报错

4.4 (?P=name) 在正则后面引用前面的组

在同一个字符串中匹配由(?P<name)分组的之前文本，可以使用 (?P=name)。

请注意，此处 pattern 中的 (?P=name) 是为了匹配前面的分组内容，而不是继续分组，所以不视同有效的 ()，不会列入数字 ID 的计数中。

用 (?P<name)、 (?P=name)的好处很明显，相对于数字 ID 方式，它不容易出错。

下面用代码来表示：

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?P<NAME>happy)\s(\w+)!.*(?P=NAME))', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    print("res.group(3)",res.group(3)) #显示第三个()包括的对象
    #显示 NAME 表示的对象，即和 res.group(2) 的结果为同一个
    print("res.group('NAME')",res.group('NAME')) 
    #请注意，此处pattern 虽然有第四个(),但是第四个() 是为了匹配前面的分组内容，
    #而不是继续分组，所以不视同有效的()。因为没有有效的第四个()，所以会报错
    print("res.group(4)",res.group(4))

4.5 (?#comments) 标示注释，所有内容都被忽略

请注意，此处 pattern 中的 (?#comments) 是为了标示注释，所有内容都被忽略，所以不视同有效的 ()，不会列入数字 ID 的计数中。

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?#comments-happy)\s(\w+)!)', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    
    #请注意，此处pattern 虽然有第三个(),但是(?#comments-happy) 是为了注释，
    #而不是实际分组，所以不视同有效的()。因为总共只有两个有效的()，所以提取res.groups(3)会报错
    print("res.group(3)",res.group(3))

4.6 (?=...) 正向前行匹配，以 ... 字符串结尾才匹配

匹配条件是如果...出现在之后的位置，才进行匹配输入字符串，(?=...) 中的 ... 不参与分组；又称作正向前视断言。

举例说明：

word="I am happy now! let's have a happy day! "    
res = re.search(r'(\s(\w+)!(?=\s\w{1,3}))', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    
    #请注意，此处pattern 虽然有第三个(),但是(?=\s\w{1,3})) 是为了正向前行匹配，
    #而不是实际分组，所以不视同有效的()。因为总共只有两个有效的()，所以提取res.groups(3)会报错
    print("res.group(3)",res.group(3))

4.7 (?!...) 负向前行匹配，不以 ... 字符串结尾才匹配

匹配条件是如果 ... 不出现在之后的位置，才进行匹配输入字符串，(?!...) 中的 ... 不参与分组；又称作负向前视断言

word="I am happy now! let's have a happy day! "    
res = re.search(r'(\s(\w+)!(?!\s\w{1,3}))', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    
    #请注意，此处pattern 虽然有第三个(),但是(?!\s\w{1,3}) 是为了负向前行匹配，
    #而不是实际分组，所以不视同有效的()。因为总共只有两个有效的()，所以提取res.groups(3)会报错
    print("res.group(3)",res.group(3))

4.8 (?<=...) 正向后行匹配，之前有 ... 字符串才进行匹配

匹配条件是如果 ... 出现在之前的位置，才进行匹配；称作正向后视断言。(?<...) 中的 ... 不参与分组。请注意，Python 不支持可变长度的正向后视断言，会报错：“error: look-behind requires fixed-width pattern”。

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?<=\w{5})\s(\w+)!)', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    
    #请注意，此处 pattern 虽然有第三个(),但是(?<=\w{5}) 是为了正向后视断言，
    #而不是实际分组，所以不视同有效的()。因为总共只有两个有效的()，所以提取res.groups(3)会报错
    print("res.group(3)",res.group(3))

4.9 (?<!...) 负向后行匹配，之前没有 ... 字符串才进行匹配

匹配条件是如果 ... 不出现在之前的位置，而不使用输入字符串;称作负向后视断言(?<!192\.168\.)

匹配条件是如果 ... 不出现在之前的位置，才进行匹配；又称作负向后视断言。(?<!...) 中的 ... 不参与分组。请注意，Python 不支持可变长度的负向后视断言，会报错：“error: look-behind requires fixed-width pattern”。

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?<!\w{5})\s(happy day))', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    
    #请注意，此处 pattern 虽然有第三个(),但是(?<!\w{5})是为了负向后视断言，
    #而不是实际分组，所以不视同有效的()。因为总共只有两个有效的()，所以提取res.groups(3)会报错
    print("res.group(3)",res.group(3))

4.10 (?(id/name)Y|N) 匹配不同的字符串

如果分组所提供的 id 或者 name 存在，对于给出的 id 或者 name，先尝试去匹配 Y 部分的内容；如果 id 或 name 条件不满足，则去匹配 N 部分的内容；|N是可选项。

word="I am happy now! let's have a happy day! "    
res = re.search(r'((?P<NAME>Happy|happy)\s(\w+)!)', word)
if(res is not None):
    print("-"*40)
    print(res)
    print("res.group()",res.group())
    print("res.groups()",res.groups()) #显示所有子组
    print("res.group(0)",res.group(0))  #显示全部匹配对象
    print("res.group(1)",res.group(1)) #显示第一个()包括的对象
    print("res.group(2)",res.group(2)) #显示第二个()包括的对象
    print("res.group(3)",res.group(3)) #显示第三个()包括的对象
    #显示 NAME 表示的对象，即和 res.group(2) 的结果为同一个
    print("res.group('NAME')",res.group('NAME')) 
    print("res.group(4)",res.group(4)) #因为没有第四个()，所以会报错

'''

要是大家觉得写得还行，麻烦点个赞或者收藏吧，最好加关注我，想个博客涨涨人气，非常感谢！

'''

江南野栀子

关注

19
点赞
踩
123

收藏

觉得还不错? 一键收藏
打赏
7
评论
Python 正则表达式使用--Re 模块详解

1. 常用正则表达式符号和特殊字符2. Re 模块：核心函数和方法2.1 re.compile() 编译函数2.1.1re.compile() 语法格式2.1.2re.compile() 用法2.2 re.match() 和 re.search() 匹配和搜索函数2.2.1re.match() 语法格式2.2.2re.match() 用法2.2.3re.search() 语法格式2.2.4re.search() 用法2.3 re.findall() 和
复制链接

扫一扫