python正则表达式详解之元字符及分组（小白必看）

一、正则表达式
1.1 对正则表达式的理解及python中正则使用的基本方法
1.1.1对正则表达式的理解

正则表达式由普通文本字符和特殊字符（元字符）两种字符组成的一系列的字符串的模式，
。元字符在正则表达式中具有特殊意义，它让正则表达式具有更丰富的表达能力。例如，
正则表达式 r"a.d"中 ，字符 ‘a’ 和 ‘d’ 是普通字符，’.’ 是元字符，. 可以指代任意字符，
它能匹配 ‘a1d’、’a2d’、’acd’等。

1.1.2python中正则表达式的基本使用方法

在Python中，利用re模块处理正则表达式，如下代码：

import re
 
#字符串1
regx_string='aab'
 
#字符串2
regx_string2='anb'
 
#生成一个匹配的正则表达式对象
pattern=re.compile('a.b')
 
#匹配字符串1
m1=pattern.match(regx_string)
 
print(m1)
# <_sre.SRE_Match object; span=(0, 3), match='aab'>
 
#匹配字符串2
m2=pattern.match(regx_string2)
 
print(m2)
# <_sre.SRE_Match object; span=(0, 3), match='anb'>
 
#字符串3
regx_string3='and'
 
m3=pattern.match(regx_string3)
 
print(m3)
# None

说明：match方法在字符串与正则表达式匹配的时候，返回的是一个Match对象，如果不匹配，则返回的是None

python中另一种使用正则的方法：

# match(pattern, string, flags=0)
m4=re.match('a.b',regx_string)
 
print(m4)
# <_sre.SRE_Match object; span=(0, 3), match='aab'>

1.2 python正则表达式中的元字符

1.2.1："."

“.” 匹配除换行符之外的任何字符：字母、数字、符号、空白字符.

#示例：
#匹配一个以ab开关的字符串
print(re.match('^ab.*','abccd$#2'))
# <_sre.SRE_Match object; span=(0, 8), match='abccd$#2'>
 
#匹配一个以ac开关的字符串
print(re.match('^ac.*','abccd$#2'))
# None

1.2.3："$"

“$” 匹配字符串的末尾或字符串末尾的换行符之前

#示例：
#匹配一个ac结尾的字符串：
print(re.match('.*ac$','adsfasdfac'))
# <_sre.SRE_Match object; span=(0, 10), match='adsfasdfac'>
 
#看结束点
print(re.match('.*ac$','adsfacdfac\n'))
# <_sre.SRE_Match object; span=(0, 10), match='adsfacdfac'>
 
print(re.match('.*ac$','adsfac\ndfac'))
# None

说明：$是一般情况下匹配一行的末尾，如果是多行，则没法进行匹配。但可以进行专门指定匹配多行

print(re.match('.*ac$','adsfac\ndfac',re.M))
# <_sre.SRE_Match object; span=(0, 6), match='adsfac'>，这种情况相当于没有指定多行的情况下直接匹配'adsfac'

1.2.4 “*”

“*” 重复匹配零次或者更多次(贪婪模式).

贪婪模式：尽可能多的匹配遇到的重复。

print(re.match('.*ac$','adsfac\ndfac',re.M))
# <_sre.SRE_Match object; span=(0, 6), match='adsfac'>，这种情况相当于没有指定多行的情况下直接匹配'adsfac'
#示例如下：
#匹配一个以a开始，以b结束的字符串
print(re.match('a.*b','aaaadbdgdbddf546b'))
#<_sre.SRE_Match object; span=(0, 17), match='aaaadbdgdbddf546b'>
 
#限制贪婪模式
print(re.match('a.*?b','aaaadbdgdbddf546b'))
#<_sre.SRE_Match object; span=(0, 6), match='aaaadb'>

1.2.5 “+”

“+” 重复匹配1次或者更多次(贪婪模式)

示例：分别用*和+匹配一个以含有'ab'的字符串
#匹配字符串：aaabcdbfdd
 
print(re.match('^.*(ab)*.*$','aaabcdbfdd'))
# <_sre.SRE_Match object; span=(0, 10), match='aaabcdbfdd'>
 
print(re.match('^.*(ab)+.*$','aaabcdbfdd'))
# <_sre.SRE_Match object; span=(0, 9), match='aaadcdfbb'>
 
#匹配字符串：aaadcdfcc
 
print(re.match('^.*(ab)*.*$','aaadcdfcc'))
# <_sre.SRE_Match object; span=(0, 9), match='aaadcdfcc'>
 
print(re.match('^.*(ab)+.*$','aaadcdfbb'))
# None

1.2.6 “?”

“?” 重复匹配0次或者1次(贪婪模式).

#示例：分别用aaabcdbfdd和aaadcdfbb匹配正则表达式'^.*ab?.*$'
 
print(re.match('^.*(ab)?.*$','aaabcdbfdd'))
# <_sre.SRE_Match object; span=(0, 10), match='aaabcdbfdd'>
 
print(re.match('^.*(ab)?.*$','aaadcdfbb'))
# <_sre.SRE_Match object; span=(0, 9), match='aaadcdfbb'>

1.2.6 “?”

“?” 重复匹配0次或者1次(贪婪模式).

#示例：分别用aaabcdbfdd和aaadcdfbb匹配正则表达式'^.*ab?.*$'
 
print(re.match('^.*(ab)?.*$','aaabcdbfdd'))
# <_sre.SRE_Match object; span=(0, 10), match='aaabcdbfdd'>
 
print(re.match('^.*(ab)?.*$','aaadcdfbb'))
# <_sre.SRE_Match object; span=(0, 9), match='aaadcdfbb'>

1.2.7 “*?,+?,??”

*?,+?,?? *,+,?的非贪婪模式.

# 示例：正则表达式：'(ab)*','(ab)*?','(ab)+','(ab)+?','(ab)?','(ab)??',匹配字符串：ababababababababab
#说明：Match对象的group方法在参数为零的情况下，返回的是整个匹配的字符串
print(re.match('(ab)*','ababababababababab').group())
# ababababababababab
 
print(re.match('(ab)*?','ababababababababab').group())
# ''0个
 
print(re.match('(ab)+','ababababababababab').group())
# ababababababababab
 
print(re.match('(ab)+?','ababababababababab').group())
# ab
 
print(re.match('(ab)?','ababababababababab').group())
# ab
 
print(re.match('(ab)??','ababababababababab').group())
# ''0个

1.2.8 “{m}”

“{m}” 重复匹配m次
1.2.9 “{m,n}”

{m,n} 重复匹配m次或者n次(贪婪模式)
1.2.10 “{m,n}？”

{m,n}? {m,n}的非贪婪模式.

#示例：正则表达式：'(ab){1,3}','(ab){2,5}','(ab){1,3}?','(ab){2,5}?',匹配字符串：ababababababababab
print(re.match('(ab){1,3}','ababababababababab').group())
# ababab
 
print(re.match('(ab){1,3}?','ababababababababab').group())
# ab
 
print(re.match('(ab){2,5}','ababababababababab').group())
# ababababab
 
print(re.match('(ab){2,5}?','ababababababababab').group())
# abab

1.2.11 “\”

“\” 转义特殊字符或表示特殊序列

#示例：转义特殊字符-->匹配.+?*\
 
print(re.match('.+?*','.+?*').group())
# sre_constants.error: multiple repeat at position 3

说明：该错误说明我们在表达式中使用了多个表示重复功能的元字符，而不是我们原先设想的表示字符串“.+?*\”

print(re.match('\.\+\?\*','.+?*').group())
# .+?*
 
# 表示特殊序列:\d 表示所有的数字,\w表示所有的字母数字
 
print(re.match('\d*','25*29').group())
# 25
 
print(re.match('\w+','1134afdads').group())
# 1134afdads

1.2.13 “[]”

[] 表示一组字符，如果以"^"为第一个字符，表示一组字符的互补集.

# 示例：匹配一个含有1-5的字符串
print(re.match('[12345]+','1235425422119877').group())
# 123542542211
 
print(re.match('[1-5]+','1235425422119877').group())
# 123542542211
 
#匹配除了abc以外的所有字符
print(re.match('[^abc]+','155acdefafdf').group())
# 155

1.2.13 “|”

“|” A|B, 选择分支，或者匹配A或者匹配B.

# 示例：匹配由[a-z]的小写字母或[2-9]的数字组成的字符串
 
print(re.match('[a-z]+|[2-9]+','abcdefga').group())
# abcdefga
 
print(re.match('[a-z]+|[2-9]+','32456546545').group())
# 32456546545
 
print(re.match('[a-z]+|[2-9]+','adfasf32456546545').group())
# adfasf
 
print(re.match('[a-z]+|[2-9]+','2356safdsfa').group())
# 2356
 
print(re.match('[a-z]+|[2-9]+','12356safdsfa'))
# None

1.3 python正则中的分组
1.3.1：(…)

(…) 匹配一个分组，将括号中的内容当作一个整体来对待

# 示例：
print(re.match('ab*','abbb').group())
# abbb
 
print(re.match('(ab)*','abbb').group())
# ab

1.3.2：(?aiLmsux)

(?aiLmsux) 为表达式设置 A, I, L, M, S, U, 或 X 标志.标志的具体含义，会在后面的内容中详细解读

#示例:I标志表示大小写不敏感匹配如下
 
print(re.match('[A-Z]+','acdadsfadf'))
# None
 
print(re.match('[A-Z]+(?i)','acdadsfadf'))
# <_sre.SRE_Match object; span=(0, 10), match='acdadsfadf'>
 
#也可以这样进行设置
print(re.match('[A-Z]+','acdadsfadf',re.I))
# <_sre.SRE_Match object; span=(0, 10), match='acdadsfadf'>

1.3.3：(?:…)

(?:…) 非分组模式的分组匹配

#示例:
print(re.match('(?:\w+) (?:\w+)','Eric Brown').group())
# Eric Brown
 
# print(re.match('(?:\w+) (?:\w+)','Eric Brown').group(1))
# IndexError: no such group
 
print(re.match('(\w+) (\w+)','Eric Brown').group())
# Eric Brown
 
print(re.match('(\w+) (\w+)','Eric Brown').group(1))
# Eric 
 
print(re.match('(\w+) (\w+)','Eric Brown').group(2))
# Brown

说明:在非分组模式下,字符串的匹配只会将整个的匹配结果返回,而对于表达式中每一个组的匹配情况则不会进行保存.

而在分组模式下,不但保存了整个分组的匹配结果,也将表达式中每一个组的匹配结果分开保存,关于Match对象的分组，后面有内容会进行详细介绍

1.3.4：(?P…)

(?P…) 组匹配的子字符串,可以能一个名称访问.

# 示例:
print(re.match('(?P\w+) (?P\w+)','Eric Brown').group())
# Eric Brown
 
print(re.match('(?P\w+) (?P\w+)','Eric Brown').group('first_name'))
# Eric
 
print(re.match('(?P\w+) (?P\w+)','Eric Brown').group('last_name'))
# Brown

1.3.5：(?P=name)

(?P=name) 对指定的组反向的引用,以前面的以name为名称的组匹配的文本为分组内容,匹配后面的内容

#示例:
pattern=re.compile('(?P[1-9]){5}@(?P[a-z])+\.(?P=letters)+')
 
m=pattern.match('[email protected]')
 
print(m.group())
# [email protected]
 
print(m.group(1))
# 5
 
print(m.group(2))
# q

1.3.6：(?=…)

(?=…) 当该表达式匹配成功的时候,它的前面的表达式才会匹配.

#示例:
 
print(re.match('\w+@(?=\d+)','abcds@123456').group())
# abcds@
 

说明:上面表达式的表示:在@后面必然跟的是数字,如果不是,则字符串不符合要求,如果是，匹配返回的内容则是前面的字符串与@
1.3.6：(?!..)
(?!..) 当该表达式不匹配的时候,它的前面的表达式都会匹配成功

#示例:
print(re.match('\w+@(?!\d+)','abcds@dfa').group())
# abcds@

1.3.7：(?<=…)

(?<=…) 匹配以…开始的后面部分的字串,只能是固定的长度,也就是一个明确的表达式.

#示例:
print(re.match('(?<=abc)def', 'abcdef'))
#None
 
print(re.search('(?<=abc)def', 'abcdef'))
#<_sre.SRE_Match object; span=(3, 6), match='def'>

说明:该模式不能于一个字符串的开始

print(re.match('(\w+)(?<=zhang)san', 'myzhangsan').group())
# myzhangsan

1.3.8：(?

(?

print(re.match('(\w+)(?, 'mylisan').group())

1.3.9：(?(id/name)yes|no)

(?(id/name)yes|no) 如果前面以id/name表示的正则匹配，
则利用yes处的正则表达式匹配后面的字符串，否则用no处的匹配，

#示例：
#下面的例子检查的是一个字符串两边的括号是否配对，如果没有括号或配对，则匹配成功，否则将匹配失败。
pattern=re.compile('(?P\()?\w+(?(lefg_bracket)\)|$)')
 
#两边有括号
m=pattern.match('(ab123456)')
 
print(m.group())
# (ab123456)
 
#两边没有括号
m=pattern.match('cdefghj')
 
print(m.group())
# cdefghj
 
#一边有括号
m=pattern.match('(abdcd')
 
print(m)
# None