Python正则表达式
一.个人资料
正则表达式是一个特殊字符串，有助于轻松检查字符串是否与模式匹配。
本质上，正则表达式(或RE )是一种小型、高度专业化的编程语言。
内置于python中，通过re模块实现。
正则表达式模块编译成一系列字节码，由用c编写的匹配引擎执行。
二、文字匹配(普通文字、元文字) :
普通文字：大多数文字和文字与自己一致
#首先引入re模块
导入re
#请到字符串中，以一个列表的形式返回所有匹配的结果
re.findall(jwDWN，) jwdwnfeaedfadfx ) )。
[jwdwn] #常规字符串匹配
元字符：^ $ *？ ({} [] |(() ) ) ) ) ) ) ) ) )
'.' 除换行符以外的任何字符
re.findall(al.x )、alqxqqqqqqq ) )。
[alqx]
' ^ '开始位置一致
re.findall((^al.x )，) alxxqqqqqqq )。
[alxx]
' $ '结束位置一致
re.findall(al.x$ )、qqqqqqqalxx ) )。
[alxx]
'？ 匹配0次或1次
re.findall(al . x '，' qqqqqqqqjwdwnqqqqqqq ' )
[jwdwn]
“*”匹配0到多个字符
re.findall(al.*x )、) alqqqqqqqx ) )
[alqqqqqqqx]
“”匹配一个到多个字符
#之间没有字符串就不一致
re.findall(al.x )、) qqqqalxqqq ) )。
[]
'？ 匹配0到1个字符
re.findall(al . x '，' qqqqqalxxqqqqq ' )
[alxx]
' {} '与固定数量一致
#3次匹配
re.findall((^al.{3}x )，) qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
[alqqqx]
#3~5次匹配
re.find all ((^ al.{ 3，5 } x )，) qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
[alqqqqx]
注： {1，}这样表示1至多次，{，9}这样表示0至9次
与“[]”对应的位置可以是字符集中的任何字符
re.findall(a[CD]b )、(acb ) ) )
['acb']
re.findall(a[CD]b )、() adb ) )
['adb']
re.findall(a[CD]b )、(acdb ) ) )
[]
re.findall(a[CD]b )、() adcb ) )
['adcb']
注：大括号中以前介绍的元字符没有特殊意义。 ' ^ '，'-'，''有特殊的意义
' ^ '表示非
re.findall(al ) ) f ) x )、) qqqqalfxppppp ) )
[]
'-'表示范围
[1-9]表示1至9
[a-z]表示a-z
re.findall(al ) a-z (x )、() qqqqalxxppppp ) ) ) )。
[alxx]
在“”之后添加元字符将取消元字符功能
在“”之后添加普通字符以实现特殊功能
d匹配任意十进制数：它相当于[0-9]
D与任何非数字字符匹配：这相当于[^0-9]
s匹配任何空字符：这相当于[tnrfv]
S与非空字符匹配：相当于[^tnrfv]
w与任何字母数字字符匹配：这相当于[a-zA-Z0-9_]
W与任何非字母数字字符匹配：这相当于[^a-zA-Z0-9_]
b匹配单词边界，即单词和空格之间的位置。 匹配单词的边界。 包括开始和结束。 其中，“单词”是指由连续的字母、数字下划线构成的字符串。
请注意b的定义是w和w之间的边界。 这是“零宽度定义符”(zero-width assertions )，只需将单词的开头和结尾匹配即可。 单词被定义
为一个字母数字序列，因此词尾就是用空白符或非字母数字符来表示的。三、函数
re.match函数
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
函数用法：
re.match(pattern, string, flags=0)
函数的参数说明：
pattern匹配的正则表达式
string要匹配的字符串。
flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
# 返回match的object的结果，通过group返回被RE匹配的字符串
obj = re.match('com','comwwww.runcomobb')
print(obj)
# 输出
obj = re.match('com','comwwww.runcomobb').group()
print(obj)
# 输出
com
除了group还有什么呢：
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配(开始，结束)的位置
obj = re.match('com','comwwww.runcomobb').span()
print(obj)
# 输出
(0, 3)
re.search函数
re.search 扫描整个字符串并返回第一个成功的匹配。
函数用法：
re.search(pattern, string, flags=0)
re.search与re.match用法看似差不多区别在于，re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
obj = re.search('com','wwww.runcomobb')
print(obj)
# 输出
obj = re.search('com','wwww.runcomobb').group()
print(obj)
# 输出
com
re.findall函数
re.findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；空的匹配也会包含在结果中。
函数用法：
findall(pattern, string, flags=0)
re.sub函数
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
函数语法：
re.sub(pattern, repl, string, count=0, flags=0)
函数的参数说明：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
# 匹配替换
print(re.sub("g.t", "have", "I get A, I got B, I gut C"))
# 输出
I have A, I have B, I have C
# 匹配替换2次
print(re.sub("g.t", "have", "I get A, I got B, I gut C"，2))
# 输出
I have A, I have B, I gut C
# 匹配替换，并打印次数
print(re.subn("g.t", "have", "I get A, I got B, I gut C"))
# 输出
('I have A, I have B, I have C', 3)
re.split函数
re.split，根据正则匹配分割字符串
函数语法：
split(pattern, string, maxsplit=0, flags=0)
函数的参数说明：
pattern： 正则模型
string ： 要匹配的字符串
maxsplit：指定分割个数
flags ： 匹配模式
print(re.split('d+','one1two2three3four4'))
# 输出
['one', 'two', 'three', 'four', '']
re.compile函数
这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I |re.M
可以把正则表达式编译成一个正则表达式的对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。
函数语法：
re.compile(strPattern[, flag])
正则表达式修饰符 - 可选标志：
re.I 使匹配对大小写不敏感
re.L 做本地化识别(locale-aware)匹配
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
re.U 根据Unicode字符集解析字符。这个标志影响 w, W, b, B.
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
text = "Bourbon is a handsome boy, he is cool, clever, and so on..."
# 查找所有包含'our'的单词
regex = re.compile(r'w*ourw*')
print(regex.findall(text))
# 输出
['Bourbon']
*re.finditer(pattern, string[, flags])：
和re.findall的功能一样，区别在于finditer返回的是iter的对象，我们通过下面的例子来感受一下：
import re
obj = re.finditer(r'd+','one1two2three3four4')
print(obj)
# 输出
for i in obj:
print(i.group())
# 输出
1
2
3
4
------------------------------------------------------------------------
# 当然也可以写成这样，利用上面所学到的compile函数
pattern = re.compile(r'd+')
for i in re.finditer(pattern, 'one1two2three3four4'):
print(i.group())
# 输出
1
2
3
4
四、分组
去已经匹配到的数据中再提取数据
#为何要有分组？提取匹配成功的指定内容(先匹配成功全部正则，再匹配成功的局部内容提取出来)
r= re.match("h(w+).*(?Pd)$", origin)print(r.group()) #获取匹配到的所有结果
print(r.groups()) #获取模型中匹配到的分组结果
print(r.groupdict()) #获取模型中匹配到的分组中所有执行了key的组
r= re.search("a(w+).*(?Pd)$", origin)print(r.group()) #获取匹配到的所有结果
print(r.groups()) #获取模型中匹配到的分组结果
print(r.groupdict()) #获取模型中匹配到的分组中所有执行了key的组
origin= "hello jwdwn bcd abcd lge acd 19"r= re.findall("a((w*)c)(d)", origin)print(r)
origin= "hello jwdwn bcd jwdwn lge jwdwn acd 19"r1= re.split("(jwdwn)", origin, 1)print(r1)
r2= re.split("(al(ex))", origin, 1)print(r2)
分组