import re

元字符

px* 可以匹配 p px px...
px+ 可以匹配 px px... 但是不能匹配到p

默认的匹配都是贪婪匹配
贪婪匹配就是一次匹配尽可能多的内容

比如正则是 'aoe+'  要匹配的字符串是 'aoeeeeee'  它可以匹配到aoeeeeee
但是如果正则是 'aoe+?' 的话 它只能匹配到'aoe'
?放在+ * {n,m}是取消贪婪匹配的 

同时?也是匹配0或1次


\ 是转义符
可以让有特殊意义的元字符失效  比如\. 只是用来匹配. 而不是除换行之外的任意单个字符
可以让普通字符具有特殊意义    比如\d 不是用来匹配字母d,而是用来匹配单个数字0-9  等价于[0-9]



^a.*b$ 同时满足以a开头以b结尾

[] 正则中学名叫 字符集
[abc] 匹配a或b或c 中的其中一个
[a-c] -用于表示范围 效果和上面的相同  顺序是按照ascii码排的
[^abc] 匹配除a或b或c之外的任意一个字符

一些应用

?P<f>\b\w+\b 是说给 \b\w+\b 这段正则命名为f
匹配AA这种形式的(?P<f>\b\w+\b)(?P=f)

关于分组

首先是分组的扩展语法

正则中()是用来分组的

一般用match和search这两个方法匹配关于分组的正则
match和search方法匹配成功后会返回match对象

print(re.search("(\d{3})(\w+)(\d{3})","123abcd123"))
# <_sre.SRE_Match object; span=(0, 10), match='123abcd123'>

match对象的主要方法

groups() 将匹配到的内容分组 放到元组中 然后返回这个元组

print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").groups())
('123', 'abcd', '123')

group() 返回内容

print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").group(0))
print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").group())
# 返回大正则匹配到的内容

print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").group(1))   # 第一组
print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").group(2))   # 第二组
print(re.search("(\d{3})(\w+)(\d{3})","123abcd123").group(3))   # 第三组

# 如果这里将分组命名的话 
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").group("abc"))    # 123
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").group("zzz"))    # abcd

# 前面(?P<abc>\d{3}) 就是将该分组命名为abc 
# 后面如果要匹配相同的内容的话 可以额(?P=abc)
# group()可以通过传入组名来获取匹配到的内容

print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").group('abc',"zzz"))
# ('123', 'abcd')
# 传入多个组号或组名 可以返回多个元素组成的元素

groupdict() 组名为key 匹配到的内容为value

print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").groupdict())
# {'abc': '123', 'zzz': 'abcd'}

start() 返回指定分组的起始索引位置

print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").start(1))
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").start(2))
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").start("abc"))
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").start("zzz"))

# 执行结果
0
3
0
3

end() 返回指定分组的结束为止的前一个为止

print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").end(2))  # 7
print(re.search("(?P<abc>\d{3})(?P<zzz>\w+)(?P=abc)","123abcd123").end("zzz"))  # 7

re模块方法

正则表达式对象

# 不适用正则对象的话
print(re.findall("\d+","123abc123"))
# ['123', '123']


# 使用正则对象的话
com = re.compile("\d+")  # 规则
print(com.findall("123abc123"))  # 结果通过规则来调用方法
# ['123', '123']

# 把规则提出来,然后进行重复调用

match search findall

sub subn

sub还可以指定替换次数(第三个参数)

split

一个re.split的坑

print(re.split("[ab]","abc"))       # ['', '', 'c']
# 首先按a来分'abc' a左边没有内容 就为''
# 右边有bc 现在分出来 '' 和 'bc' 两部分
# 然后按b来分 b来分'bc' 左边没有内容 就为''
# 右边有一个'c' 所以最后得到 ['', '', 'c']


###########################################################
print(re.split("[ab]","asdabcd"))
# 首先按a来分'asdabcd' 左边为空 右边为sdabcd
# 然后按a来分右边为sdabcd 左边为sd 右边为bcd
# 然后按b来分 bcd 左边为 '' 右边为 cd
# 所以结果是 ['','sd','','cd']