一、什么是正则：
1、正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配
2、re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
总结一下，先整体了解re正则：
- pattern = re.compile("\d") 将正则表达式编译成一个Pattern规则对象
- pattern.match() 从开始位置开始往后查找，返回第一个符合规则的对象
- pattern.search() 从任何位置开始往后查找，返回第一个符合规则的对象
- pattern.findall() 所有的全部匹配，返回列表
- pattern.finditer() 所有的全部匹配，返回的是一个迭代器
- pattern.split() 分割字符串，返回列表
- pattern.sub() 替换
二、re模块
2.1match方法
2.1.1语法：pattern.match(str, start, end)
实例：
import re #导入re模块
pattern = re.compile(r'\d+') #此处加r表示不转义字符串
m = pattern.match('aaaa123bbb456')
m2 = pattern.match('aaaa123bbb456', 4,10)
print(m) # None
print(m2.group()) # 123match在没有匹配到数据的时候返回的是 None
match匹配到数据后返回的是一个对象
2.1.2match分组匹配
import re
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
m = pattern.match('hello world Hello Python')
print(m.group()) # hello world
print(m.group(0)) # hello world
print(m.group(1)) # hello
print(m.group(2)) # world三. re中的编译函数
3.1 compile方法
那么如果一个正则表达式要重复使用几千次，出于效率的考虑，我们是不是应该先把这个正则先预编译好，接下来重复使用时就不再需要编译这个步骤了，直接匹配，提高我们的效率
import re
re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$') # 编译
A = re_telephone.match('010-12345').groups() # 使用
print(A) # 结果 ('010', '12345')
B = re_telephone.match('010-8086').groups() # 使用
print(B) # 结果 ('010', '8086')编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。
3.2 search方法
re.search()方法扫描整个字符串，并返回第一个成功的匹配。如果匹配失败，则返回None。
与re.match()方法不同，re.match()方法要求必须从字符串的开头进行匹配，如果字符串的开头不匹配，整个匹配就失败了；
re.search()并不要求必须从字符串的开头进行匹配，也就是说，正则表达式可以是字符串的一部分
语法：re.search(pattern, string, flags=0)
- pattern : 正则中的模式字符串。
- string : 要被查找替换的原始字符串。
- flags : 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
例1：
import re
content = 'Hello 123456789 Word_This is just a test 666 Test'
result = re.search('(\d+).*?(\d+).*', content)
print(result)
print(result.group()) # print(result.group(0)) 同样效果字符串
print(result.groups())
print(result.group(1))运行结果：
<_sre.SRE_Match object; span=(6, 49), match='123456789 Word_This is just a test 666 Test'>
123456789 Word_This is just a test 666 Test
('123456789', '666')
123456789
666
Process finished with exit code 0例2：只匹配数字
import re
content = 'Hello 123456789 Word_This is just a test 666 Test'
result = re.search('(\d+)', content)
print(result)
print(result.group()) # print(result.group(0)) 同样效果字符串
print(result.groups())
运行结果：
<_sre.SRE_Match object; span=(6, 15), match='123456789'>
123456789
('123456789',)
123456789
Process finished with exit code 0
3.3 finall方法
返回一个包含所有匹配到的字符串的列表。
- pattern 匹配模式，由 re.compile 获得
- string 需要匹配的字符串
import re
str = 'say hello world! hello python'
pattern = re.compile(r'(?P<first>h\w)(?P<symbol>l+)(?P<last>o\s)') # 分组，0 组是整个 world!, 1组 or，2组 ld!
match = re.findall(pattern, str)
print(match)运行结果：
[('he', 'll', 'o '), ('he', 'll', 'o ')]另外，多讲两个名字类似的：
re.finditer ：re.finditer(pattern, string[, flags=0])
re.findall：re.findall(pattern, string[, flags=0])
- pattern compile 生成的正则表达式对象，或者自定义也可
- string 要匹配的字符串
findall 返回一个包含所有匹配到的字符的列表，列表类以元组的形式存在。
finditer 返回一个可迭代对象。
例1：
pattern = re.compile(r'\d+@\w+.com') #通过 re.compile 获得一个正则表达式对象
result_finditer = re.finditer(pattern, content)
print(type(result_finditer))
print(result_finditer) # finditer 得到的结果是个可迭代对象
for i in result_finditer: # i 本身也是可迭代对象，所以下面要使用 i.group()
print(i.group())
result_findall = re.findall(pattern, content)
print(type(result_findall)) # findall 得到的是一个列表
print(result_findall)
for p in result_finditer:
print(p)运行结果：
<class 'callable_iterator'>
<callable_iterator object at 0x10545ec88>
123456@163.com
234567@163.com
345678@163.com
<class 'list'>
['123456@163.com', '234567@163.com', '345678@163.com']由结果可知：finditer 得到的是可迭代对象，finfdall 得到的是一个列表
例2：
import re
content = '''email:123456@163.com
email:234567@163.com
email:345678@163.com
'''
pattern = re.compile(r'(?P<number>\d+)@(?P<mail_type>\w+).com')
result_finditer = re.finditer(pattern, content)
print(type(result_finditer))
print(result_finditer)
iter_dict = {} # 把最后得到的结果
for i in result_finditer:
print('邮箱号码是：', i.group(1),'邮箱类型是：',i.group(2))
number = i.group(1)
mail_type = i.group(2)
iter_dict.setdefault(number, mail_type) # 使用 dict.setdefault 创建了一个字典
print(iter_dict)
print('+++++++++++++++++++++++++++++++')
result_findall = re.findall(pattern, content)
print(result_findall)
print(type(result_findall))运行结果：
<class 'callable_iterator'>
<callable_iterator object at 0x104c5cbe0>
邮箱号码是： 123456 邮箱类型是： 163
邮箱号码是： 234567 邮箱类型是： 163
邮箱号码是： 345678 邮箱类型是： 163
{'123456': '163', '234567': '163', '345678': '163'}
+++++++++++++++++++++++++++++++
[('123456', '163'), ('234567', '163'), ('345678', '163')]
<class 'list'>finditer 得到的可迭代对象 i，也可以使用 lastindex，lastgroup 方法。
print('lastgroup 最后一个被捕获的分组的名字',i.lastgroup)
findall 当正则没有分组，返回就是正则匹配。
e.findall(r"\d+@\w+.com", content)
['2345678@163.com', '2345678@163.com', '345678@163.com']有一个分组返回的是分组的匹配
re.findall(r"(\d+)@\w+.com", content)
['2345678', '2345678', '345678']多个分组时，将结果作为 元组，一并存入到 列表中。
re.findall(r"(\d+)@(\w+).com", content)
[('2345678', '163'), ('2345678', '163'), ('345678', '163')]小结：search找到就返回，finall全部找到才返回
3.5 split方法
split能够按照所能匹配的字串将字符串进行切分，返回切分后的字符串列表
语法：re.split(pattern, string[, maxsplit=0, flags=0])
pattern:匹配的字符串
string:需要切分的字符串
maxsplit:分隔次数，默认为0(即不限次数)
flags:标志位，用于控制正则表达式的匹配方式，比如：是否区分大小写
import re
line = 'aaa bbb ccc;ddd eee,fff'
print(line)
'aaa bbb ccc;ddd eee,fff'单字符切割
re.split(r';',line)
结果：
['aaa bbb ccc', 'ddd\teee,fff']两个字符以上切割需要放在 [ ] 中
re.split(r'[;,]',line)
结果：
['aaa bbb ccc', 'ddd\teee', 'fff']所有空白字符切割
re.split(r'([;])',line)
结果：
['aaa bbb ccc', ';', 'ddd\teee,fff']不想保留分隔符，以（?:...）的形式指定
re.split(r'(?:[;])',line)
结果：
['aaa bbb ccc', 'ddd\teee,fff']四. 贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。
Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；
非贪婪则相反，总是尝试匹配尽可能少的字符。在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪
总结一下：
- 贪婪：在满足条件情况下尽可能匹配到数据
- 非贪婪：满足条件就可以，在
"*","?","+","{m,n}"后面加上？，就能将贪婪变成非贪婪.
import re
# 贪婪匹配
greedy_pattern = re.compile(r'ab.*c')
greedy_match = greedy_pattern.match('abcaxc')
print("贪婪匹配结果：" + greedy_match.group())
# 非贪婪匹配
not_greedy_pattern = re.compile(r'ab.*?c')
not_greedy_match = not_greedy_pattern.match('abcaxc')
print("非贪婪匹配结果：" + not_greedy_match.group())输出：
贪婪匹配结果：abcaxc
非贪婪匹配结果：abc
