第一章：正则表达式

>>> re.search(‘^s.*$‘, ‘sllsljegleg‘)# 第一个参数：就是我们写出来的正则表达式(从表面上看就是字符串)第二个参数：就是我们匹配的字符串，如果匹配到了就返回值
<_sre.SRE_Match object; span=(0, 11), match=‘sllsljegleg‘>  # 最后match后面的就是我们匹配到的字符串
>>> re.search(‘^s.*$‘, ‘llsljegleg‘) # 如果没有匹配到就没有显示
>>>

>>> re.search(‘^From‘,‘From to China‘)  # 以From开头的字符串
<_sre.SRE_Match object; span=(0, 4), match=‘From‘>

>>> re.search(‘/bin/tcsh$‘, ‘python /bin/tcsh‘) # 以/bin/tcsh结尾的字符串  
<_sre.SRE_Match object; span=(7, 16), match=‘/bin/tcsh‘>

>>> re.search(‘^Subject:hi$‘, ‘Subject:hi‘)  # 如果前面有脱字符，后面美元符，就代表只匹配里面的值，此例中就是只匹配Subject:hi
<_sre.SRE_Match object; span=(0, 10), match=‘Subject:hi‘>
>>>

>>> re.search(‘\$‘, ‘$‘)   通过\转义就可以匹配到$ 符了
<_sre.SRE_Match object; span=(0, 1), match=‘$‘>
>>> re.search(‘\^\$‘, ‘hello ^$‘)
<_sre.SRE_Match object; span=(6, 8), match=‘^$‘>
>>>

>>> s = ‘this island is beautiful‘
>>> import re
>>> re.search(r‘\bis‘, s)    # 此时我们会发现匹配到了索引为5，7的字符，也就是说island这个前面的is匹配到了
<_sre.SRE_Match object; span=(5, 7), match=‘is‘>
>>> re.search(r‘\bis\b‘, s)  # 如果加上\b界定上单词边界之后就会之匹匹厄后面的is了，因为前面的is并不是一个单词
<_sre.SRE_Match object; span=(12, 14), match=‘is‘>
>>>

>>> re.search(‘\d\d*‘, ‘1‘)  # 第一个\d匹配一个数字，第二个\d本来也是匹配一个数字，但是后面加上了一个*,代表前面可以不匹配，也可以匹配一次或者多次
<_sre.SRE_Match object; span=(0, 1), match=‘1‘>
>>> re.search(‘\d\d*‘, ‘12‘)   # 这个就是第二个\d匹配了1次
<_sre.SRE_Match object; span=(0, 2), match=‘12‘>
>>> re.search(‘\d\d*‘, ‘123‘)  # 这个就是第二个\d匹配了2次
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>>

>>> re.search(‘\d\d+‘, ‘1‘)   # 第一个\d匹配到了1，但是第二个\d后面有+代表最少匹配一次，但是字符串没有数字了，所以就没有匹配到值
>>> re.search(‘\d\d+‘, ‘12‘)  # 这个代表第二个\d匹配了一次
<_sre.SRE_Match object; span=(0, 2), match=‘12‘>
>>> re.search(‘\d\d+‘, ‘123‘)　　# 这个代表第二个\d匹配了两次
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>>

>>> re.search(‘\d\d?‘, ‘1‘)  # 第一个\d匹配到了1，但是第二个\d后面有？说明可以匹配0次，也就是不匹配
<_sre.SRE_Match object; span=(0, 1), match=‘1‘>
>>> re.search(‘\d\d?‘, ‘12‘)  # 第二个\d匹配了1次
<_sre.SRE_Match object; span=(0, 2), match=‘12‘>
>>> re.search(‘\d\d?‘, ‘123‘)  # 虽然匹配到了，但是发现匹配到的值还是12，最多只能匹配一次
<_sre.SRE_Match object; span=(0, 2), match=‘12‘>
>>>

>>> re.search(‘\d\d{2}‘, ‘12‘)  
>>> re.search(‘\d\d{2}‘, ‘1‘)
>>> re.search(‘\d\d{2}‘, ‘123‘)    # {2}代表前面的\d必须要匹配两次，所以只能匹配到123
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>> re.search(‘\d\d{2}‘, ‘1234‘)
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>>

>>> re.search(‘\d\d{2,4}‘, ‘12‘)
>>> re.search(‘\d\d{2,4}‘, ‘123‘)  # {2,4}代表匹配前面\d2次到4次，因此我们可以发现最少要匹配两次，最多要匹配4次
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>> re.search(‘\d\d{2,4}‘, ‘1234‘)
<_sre.SRE_Match object; span=(0, 4), match=‘1234‘>
>>> re.search(‘\d\d{2,4}‘, ‘12345‘)
<_sre.SRE_Match object; span=(0, 5), match=‘12345‘>
>>> re.search(‘\d\d{2,4}‘, ‘123456‘)
<_sre.SRE_Match object; span=(0, 5), match=‘12345‘>
>>>

# 1. 匹配字符d或b之后跟着一个o最后可以跟着一个t也可以不跟着一个t的例子
>>> re.search(‘[db]ot?‘, ‘do‘)
<_sre.SRE_Match object; span=(0, 2), match=‘do‘>
>>> re.search(‘[db]ot?‘, ‘dot‘)
<_sre.SRE_Match object; span=(0, 3), match=‘dot‘>
>>> re.search(‘[db]ot?‘, ‘bo‘)
<_sre.SRE_Match object; span=(0, 2), match=‘bo‘>
>>> re.search(‘[db]ot?‘, ‘bot‘)
<_sre.SRE_Match object; span=(0, 3), match=‘bot‘>
>>>

# 2. 匹配9-16位的信用卡号
>>> re.search(‘[0-9]{9, 16}‘, ‘1234567890‘)  # 注意不能加空格
>>> re.search(‘[0-9]{9,16}‘, ‘1234567890‘)
<_sre.SRE_Match object; span=(0, 10), match=‘1234567890‘>
>>>

# 3. 匹配全部有效的html标签
>>> re.search(‘</?[^>]+>‘, ‘</>‘)  #/?代表/可以不出现，代表的是开头的标签，也可以出现1次，代表的是结尾的标签，[^>]代表的是除了>的任何字符，后面跟上+，也就是说除了>的任何字符出现一次或者多次
<_sre.SRE_Match object; span=(0, 3), match=‘</>‘>
>>> re.search(‘</?[^>]+>‘, ‘<hello>‘)
<_sre.SRE_Match object; span=(0, 7), match=‘<hello>‘>
>>>

>>> re.search(‘f.o‘, ‘fao‘)    # 匹配字母f和o之间的任何一个字符
<_sre.SRE_Match object; span=(0, 3), match=‘fao‘>
>>> re.search(‘f.o‘, ‘f#o‘)
<_sre.SRE_Match object; span=(0, 3), match=‘f#o‘>
>>> re.search(‘f.o‘, ‘f9o‘)
<_sre.SRE_Match object; span=(0, 3), match=‘f9o‘>
>>> re.search(‘..‘, ‘js‘)      # 匹配任意的两个字符
<_sre.SRE_Match object; span=(0, 2), match=‘js‘>  
>>> re.search(‘..‘, ‘ss‘)
<_sre.SRE_Match object; span=(0, 2), match=‘ss‘>
>>>

>>> re.search(‘\d‘, ‘1‘)   # 匹配0-9的任何一个字符
<_sre.SRE_Match object; span=(0, 1), match=‘1‘>
>>> re.search(‘\d‘, ‘2‘)
<_sre.SRE_Match object; span=(0, 1), match=‘2‘>
>>> re.search(‘\d‘, ‘z‘)   # z不是0-9所以匹配不到
>>>

>>> re.search(‘\w‘, ‘1‘)  # 字母数字下滑先都可以匹配到，而且也只是匹配一个字符
<_sre.SRE_Match object; span=(0, 1), match=‘1‘>
>>> re.search(‘\w‘, ‘a‘)
<_sre.SRE_Match object; span=(0, 1), match=‘a‘>
>>> re.search(‘\w‘, ‘_‘)
<_sre.SRE_Match object; span=(0, 1), match=‘_‘>
>>> re.search(‘\w‘, ‘#‘)  # 因为#不在范围之内，所以没有匹配到
>>>

#1.   一个数字字母组成的字符串和一串由数字组成的字符串
>>> re.search(‘\w+-\d+‘, ‘ab123sejg-123456‘)   # \w代表数字字母，+代表前面的数字字母可以出现一次或者多次，也就是把字母数字组成的字符串表示好了，\d+也是一样的效果，代表的是一串由数字组成的字符串
<_sre.SRE_Match object; span=(0, 16), match=‘ab123sejg-123456‘>
>>>

#2. 以字母开头，其余字符是字母或者数字
 >>> re.search(‘^[A-Za-z]\w*‘, ‘a123lsege‘)
<_sre.SRE_Match object; span=(0, 9), match=‘a123lsege‘>
>>>

#3. 美国电话号码的格式 800-555-1212
>>>
>>> re.search(‘\d{3}-\d{3}-\d{4}‘, ‘800-555-1212‘) # \d代表的是一个数字{3}代表的是前面的数字出现三次，也就是把800给匹配出来了，然后就是单纯的一个-，后面的也是一个效果，组合起来就把电话号码给匹配出来了。
<_sre.SRE_Match object; span=(0, 11), match=‘800-555-1212‘>
>>>

# 4. 电子邮件地址xxx@yyy.com
>>> re.search(‘\w+@\w+\.com‘, ‘hwt@qq.com‘) # 首先\w+匹配一个数字字母下划线的字符串，然后一个单纯的@,然后又是一个字符串, 之后\.因为做了转义，代表的就是一个单纯的.
<_sre.SRE_Match object; span=(0, 10), match=‘hwt@qq.com‘>
>>>

>>> re.search(‘of\sthe‘, ‘of the‘)  # 就是匹配一个空格字符, 无论是换行符，\t\v\f都是可以匹配到的
<_sre.SRE_Match object; span=(0, 6), match=‘of the‘>
>>>

>>> re.search(‘[A-Z]‘, ‘D‘)  # 匹配A-Z之间的一个字符，所以D就可以匹配了,之间不能有空格
<_sre.SRE_Match object; span=(0, 1), match=‘D‘>
>>>
>>> re.search(‘[ab][cd]‘, ‘ac‘) # 从第一个方框中取出一个值与第二个方框中取出一个值进行组合，注意不能匹配到ab和cd，如果想匹配ab和cd需要通过择一匹配符号也就是[|]
<_sre.SRE_Match object; span=(0, 2), match=‘ac‘>
>>> re.search(‘[ab][cd]‘, ‘ad‘)
<_sre.SRE_Match object; span=(0, 2), match=‘ad‘>
>>> re.search(‘[ab][cd]‘, ‘ac‘)
<_sre.SRE_Match object; span=(0, 2), match=‘ac‘>
>>> re.search(‘[ab][cd]‘, ‘ad‘)
<_sre.SRE_Match object; span=(0, 2), match=‘ad‘>
>>>

# 1. z后面跟着任何一个字符然后再跟着一个0-9之间的数字
>>> re.search(‘z.[0-9]‘, ‘z#0‘)
<_sre.SRE_Match object; span=(0, 3), match=‘z#0‘>
>>> re.search(‘z.[0-9]‘, ‘z#1‘)
<_sre.SRE_Match object; span=(0, 3), match=‘z#1‘>
>>>

# 2. 除了aeiou之外的任何字符
>>> re.search(‘[^aeiou]‘, ‘s‘)
<_sre.SRE_Match object; span=(0, 1), match=‘s‘>
>>>

# 3. 除了制表符或者换行符之外的任何一个字符
>>> re.search(‘[^\n\t]‘, ‘aljg‘)
<_sre.SRE_Match object; span=(0, 1), match=‘a‘>
>>>

>>> import re
>>> re.search(‘(\d+)([a-z])(\.)(\w+)‘, ‘123c.sleg234‘)  # 这个和下面匹配的结果是一样的，意思是加上括号分组的时候并不会对匹配的结果产生影响
<_sre.SRE_Match object; span=(0, 12), match=‘123c.sleg234‘>  # 它只是通过分组给我们返回了一系列的数据，我们可以通过group(s)方法获得而已
>>> re.search(‘\d+[a-z]\.\w+‘, ‘123c.sleg234‘)　　　　　　　　 
<_sre.SRE_Match object; span=(0, 12), match=‘123c.sleg234‘>
>>>

>>> re.search(‘ab|cd‘, ‘ab‘)  # 从左边的ab和cd中匹配相应的数据，但是不会匹配ac，这也是和[]的区别
<_sre.SRE_Match object; span=(0, 2), match=‘ab‘>
>>> re.search(‘ab|cd‘, ‘cd‘)
<_sre.SRE_Match object; span=(0, 2), match=‘cd‘>
>>> re.search(‘ab|cd‘, ‘ac‘)
>>>

>>> import re
>>> s = ‘\d+‘     # 这个是自己写的正则表达式
>>> int_obj = re.compile(s)   # 通过complie方法将s编译成对象，之后就直接可以通过这个对象直接去调用方法，可以节省性能 
>>> print(int_obj.search(‘123‘))
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>> print(int_obj.search(‘123‘))
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>> print(int_obj.search(‘123‘))
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>> print(int_obj.search(‘123‘))
<_sre.SRE_Match object; span=(0, 3), match=‘123‘>
>>>

>>> s1 = ‘\d{3}-\d{3}-\d{4}‘  # 美国电话号码的格式匹配正则表达式
>>> s2 = ‘(\d{3})-(\d{3})-(\d{4})‘    # 将美国的电话号码进行分组
>>> tel = ‘099-898-2392‘  # 这是一个电话格式
>>> re.search(s1, tel)     # 之前没有学group的时候我们一直得到的都是下面的这种对象
<_sre.SRE_Match object; span=(0, 12), match=‘099-898-2392‘>
>>> re.search(s1, tel).group()   # 得到匹配的值    
‘099-898-2392‘
>>> re.search(s1, tel).group(0)  # 和上面的是一样的，因为没有分组得到的列表中就只有一个元素
‘099-898-2392‘
>>> re.search(s1, tel).group(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group
>>> re.search(s1, tel).groups()   # 没有分组的情况下groups就是空的元组
()
>>>

>>> s1 = ‘\d{3}-\d{3}-\d{4}‘  # 美国电话号码的格式匹配正则表达式
>>> s2 = ‘(\d{3})-(\d{3})-(\d{4})‘    # 将美国的电话号码进行分组
>>> tel = ‘099-898-2392‘
>>>
>>> print(re.search(s2, tel).group())
099-898-2392
>>> print(re.search(s2, tel).group(0))  # 获得的是整个匹配的对象
099-898-2392
>>> print(re.search(s2, tel).group(1))  # 第一个子组099
099
>>> print(re.search(s2, tel).group(2))  # 获得的第二个子组898
898
>>> print(re.search(s2, tel).group(3))  # 获得的第三个子组2392
2392
>>> print(re.search(s2, tel).groups())  # 获得子组的一个列表
(‘099‘, ‘898‘, ‘2392‘)
>>>

>>> re.match(‘foo‘, ‘food on the table‘).group()  # 从字符串开头开始匹配，匹配到了foo，所以group得到的是匹配到的foo
‘foo‘
>>> re.match(‘ood‘, ‘food on the table‘)　　# 从字符串开头开始匹配，发现并不是00d,所以没有匹配到结果，返回一个空
>>>

>>> re.match(‘foo‘, ‘seafood‘)   # 字符串开头并不是foo，所以match没有匹配到
>>> re.search(‘foo‘, ‘seafood‘).group()   # search是在整个字符串中匹配的，所以
‘foo‘
>>>

>>> re.match(‘foo‘, ‘seafood, seafood‘)   # 字符串开头并不是foo,所以没有匹配
>>> re.search(‘foo‘, ‘seafood, seafood‘).group()  # 在字符串匹配到第一个foo的时候就不再进行匹配了
‘foo‘
>>> re.findall(‘foo‘, ‘seafood, seafood‘)  # 在字符串给中查找到所有匹配到的字符串放在列表中
[‘foo‘, ‘foo‘]
>>> 

s = ‘This and that.‘
print(re.findall(r‘Th\w+ and th\w+‘, s))   # 会把匹配到的信息一个一个的放在列表中，此处只是匹配了一个
print(re.finditer(r‘Th\w+ and th\w+‘, s).__next__())  # iter返回一个迭代器，可以通过__next__去获得第一个对象，注意此处是类似于match获得的对象
print(re.match(‘s‘, ‘s‘))     # 为了和上面进行对比的
# 结果：
# [‘This and that‘]
# <_sre.SRE_Match object; span=(0, 13), match=‘This and that‘>
# <_sre.SRE_Match object; span=(0, 1), match=‘s‘>

s = ‘This and that.‘
print(re.findall(r‘(Th\w+) and (th\w+)‘, s))   # 有分组就会发现列表中其实放的并不是匹配到的值了，而是子组元组
print(re.finditer(r‘(Th\w+) and (th\w+)‘, s).__next__())  #但是iter得到的还是匹配的对象，如果想得到子组可以通过group去获得
print(re.match(‘s‘, ‘s‘))     # 为了和上面进行对比的

# 结果：
# [(‘This‘, ‘that‘)]
# <_sre.SRE_Match object; span=(0, 13), match=‘This and that‘>
# <_sre.SRE_Match object; span=(0, 1), match=‘s‘>

# 参数一: 正则表达式
# 参数二: 要替换的字符串
# 参数三: 源字符串
# 将替换好的字符串进行返回
s = re.sub(‘X‘, ‘Mr. Smith‘, ‘attn: X\n\nDear X, \n‘)
print(s)


#结果:
# attn: Mr. Smith
# 
# Dear Mr. Smith, 

# 参数一: 正则表达式
# 参数二: 要替换的字符串
# 参数三: 源字符串
# 将替换好的字符串进行返回
s = re.sub(‘[ae]‘, ‘X‘, ‘abcdef‘)
print(s)

# 结果:
# XbcdXf

# 2/20/[1991|91]   月/日/年  美国
# 20/2/1991   日/月/年


# 首先先把美国的时间格式用正则表达式匹配到
m = ‘(\d{1,2})/(\d{1,2})/(\d{4}|\d{2})‘
# 然后\N进行分组替换
s = re.sub(m, r‘\2/\1/\3‘, ‘2/20/1991‘)
print(s)

print(re.split(‘:‘, ‘str1:str2:str3‘))

# 结果：
# [‘str1‘, ‘str2‘, ‘str3‘]

>>> # 择一匹配
... bt = ‘bat|bet|bit‘
>>> print(re.match(bt, ‘bt‘))   # 因为此时的bt是择一匹配，也就是只能匹配bat或者bet或者bit字符串
None
>>> print(re.match(bt, ‘he bit me‘))  # 虽然字符串中有bit但是不是在开头，所以匹配不到
None
>>> print(re.search(bt, ‘he bit me‘).group())  # 这个search在整个字符串中进行查找，是可以匹配到的
bit
>>> 

>>> anyend = ‘.end‘
>>> print(re.match(anyend, ‘bend‘).group())   # .匹配了b
bend
>>> print(re.match(anyend, ‘end‘))   # 任意字符但不是没有，所以没有匹配到
None
>>> print(re.match(anyend, ‘\nend‘))  # 任意的非换行符，所以没有匹配到
None
>>> print(re.search(anyend, ‘the end‘).group())  # 用search去匹配空格一个end
 end
>>> print(re.match(‘3.14‘, ‘3014‘).group())   # . 没有加转义符代表的是匹配任意的非换行符，所以可以匹配到
3014 
>>> print(re.match(‘3\.14‘, ‘3.14‘).group())  # 这个.被转义 了
3.14
>>>

>>> re.match(‘[c2][23][dp][o2]‘, ‘c3po‘).group()  # 在正则表达式的每个方框中随机挑一个进行组合
‘c3po‘
>>> re.match(‘[c2][23][dp][o2]‘, ‘c2do‘).group()
‘c2do‘
>>> re.match(‘r2d2|c3po‘, ‘c2do‘)   # 择一匹配只能是r2d2或者是c3po和创建字符集还是有差别的
>>> re.match(‘r2d2|c3po‘, ‘r2d2‘)
<_sre.SRE_Match object; span=(0, 4), match=‘r2d2‘>
>>>

>>> # 邮件.com前面出现一个名称
... mail1 = ‘\w+@\w+\.com‘   # 可以匹配类似于hello@xxx.com
>>> # 扩展一下,使得.com前面可以出现一个或者两个名称
... mail2 = ‘\w+@(\w+\.)?\w+\.com‘  # 可以匹配类似于hello@www.xxx.com
>>>
>>> # 再扩展一下，使得.com前面可以出现任意次数的名称
... mail3 = ‘\w+@(\w+\.)*\w+\.com‘
>>> re.match(mail1, ‘nobody@xxx.com‘).group()
‘nobody@xxx.com‘
>>> re.match(mail2, ‘nobody@www.xxx.com‘).group()
‘nobody@www.xxx.com‘
>>> re.match(mail1, ‘nobody@www.xxx.com‘)
>>> re.match(mail3, ‘nobody@aaa.www.xxx.com‘).group()
‘nobody@aaa.www.xxx.com‘
>>>

>>> re.match(‘(\w+)-(\d+)‘, ‘abcde-123‘)   # 匹配字符串
<_sre.SRE_Match object; span=(0, 9), match=‘abcde-123‘>
>>> re.match(‘(\w+)-(\d+)‘, ‘abcde-123‘).group()  # 匹配完成之后用group（）的到匹配的结果
‘abcde-123‘
>>> re.match(‘(\w+)-(\d+)‘, ‘abcde-123‘).group(1)  # 用索引1得到分组一，也就是第一个括号匹配的数据
‘abcde‘
>>> re.match(‘(\w+)-(\d+)‘, ‘abcde-123‘).group(2)# 用索引2得到分组二，也就是第二个括号匹配的数据
‘123‘
>>>

>>> re.search(‘^The‘, ‘The end.‘).group()   # ^代表起始位置
‘The‘
>>> re.search(‘^The‘, ‘end. The‘)     # 不作为起始地址
>>> re.search(r‘\bThe‘, ‘bite The Dog‘).group()   #The左边是个边界，直白讲就是没有英文字符
‘The‘
>>> re.search(r‘\bThe‘, ‘biteThe Dog‘)    # The左边不是一个边界，所以没有匹配到
>>> re.search(r‘\BThe‘, ‘biteThe Dog‘).group()  # B代表的就是不是边界的时候才会被匹配
‘The‘
>>>

>>> # 示例一: 找到时间戳中一周的第几天
... data = ‘Wed Sep 16 11:17:21 1992::pscss@tdaja.org::716613441-5-6‘
>>> # 通过择一匹配把每天的单词缩写放在一个括号内，然后^表示的是一个单词的起始
... # 但是有的地方每天的单词缩写并不是这样的，所以这样子的正则表达式的适用性并不是很强
... pattr1 = ‘^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)‘
>>> print(re.search(pattr1, data).group())
Wed
>>> print(re.search(pattr1, data).group(1))
Wed
>>>
>>>
>>> # 因此下面的正则表达式的意思是任意的字母数字字符三个，但是注意写成这样‘^(\w){3}‘是有问题的
... pattr2 = ‘^(\w{3})‘
>>> print(re.search(pattr2, data).group())
Wed
>>> print(re.search(pattr2, data).group(1))
Wed
>>>
>>>
>>> # 注意写成这样是有问题的
... # 因为将{3}写在括号外部代表的是分组只有一个字符那就是\w,因此在匹配的过程中分组的值是在不停的更新迭代的，最后变成三个字符中的最后一个
... # 启发： 我们分组想要什么样的值，就把（）放在哪里。
... pattr3 = ‘^(\w){3}‘
>>> print(re.search(pattr3, data).group())
Wed
>>> print(re.search(pattr3, data).group(1))
d
>>>

# 示例二：想得到由三个连字符分隔的整数
data = ‘Wed Sep 16 11:17:21 1992::pscss@tdaja.org::716613441-5-6‘

# 通过这样的方式我们可以匹配到，但是只能称之为搜索，我们往往需要做的是匹配整个字符串，然后通过分组的形式获得我们需要的值
pattr1 = ‘\d+-\d+-\d+‘
print(re.search(pattr1, data).group())

# .+ 任意字符出现至少一次，因此匹配到了三个连字符整数的前面，之后通过后面的匹配整数，这样就实现了对整个字符串的匹配
# 然后通过分组获得我们需要的值
pattr2 = ‘.+(\d+-\d+-\d+)‘
# 当我们要获得分组的时候却发现此时的值并不是我们想要的，这是因为贪婪匹配的原因
# .+ 或匹配符合它要求的所有字符串，然后才会给后面的正则表达式进行匹配
print(re.search(pattr2, data).group(1))


# 我们可以通过？来结束贪婪匹配
pattr3 = ‘.+?(\d+-\d+-\d+)‘
print(re.search(pattr3, data).group(1))


# 结果：
# 716613441-5-6
# 1-5-6
# 716613441-5-6

# 匹配数字的正则表达式,可以匹配到1， -1， -1.1， 1.1
r‘-?\d+\.*\d*‘
# 首先应该匹配一对括号，括号不能包括括号
r‘\(\)‘
# 然后我们不是匹配空括号的，括号内要需要表达式的,表达式就需要加减乘除,但是加减乘除中特殊字符，因此我们把它转义一下
r‘\([\+\-\*\/]\)‘
# 匹配完操作符之后，就需要匹配数字了，将上面的匹配数字的正则表达式也放过来，但是这样的表达式只能匹配到带有加减乘除操作符的表达式
r‘\([\+\-\*\/]-?\d+\.*\d*\)‘
# 因此我们再[]后面加上*之后，就可以匹配到单纯的数字了
r‘\([\+\-\*\/]*-?\d+\.*\d*\)‘
# 大概的步骤都已经完成了,但是上面的操作是匹配不到‘(1-2)‘这样的字符串的，这是因为表达式只匹配了一次，而一个整数也是一个表达式
# 所以匹配不到，需要修改成下面这个样子
r‘\(([\+\-\*\/]*-?\d+\.*\d*){2,}\)‘

# r‘\d+\.*\d*[*/]-?\d+\.*\d*‘

# 乘除的表达式比较简单，把正则表达式拆成三个部分
# 1. 乘除前面的是一个数字
 r‘\d+\.*\d*‘
# 2. 乘除后面的也是一个数字，只不过后面的数字必须要匹配一个-，为的是匹配5 * -4这样的表达式
r‘-?\d+\.*\d*‘
# 3. 就是乘除符号了