Python进阶之路 — 十一

21、正则表达式
正则表达式时用来干嘛的？主要是用来匹配字符串的。由于字符串提供的匹配方法是完全匹配。而在实际情况中，我们可能只需要一串字符串中的某一部分，这时，正则表达式就非常有用了，可以实现模糊匹配。
（1）、元字符：. ^ $ * + ? {} | () \
<1> 元字符： . (通配符)

import re
# ret = re.findall('w..l','Hello world')#.只能代替任意一个字符
# print(ret)#['worl']
# ret = re.findall('w.l','Hello w\nld')#.不能代替 \n
# print(ret)#[] 未能匹配成功

<2> 元字符：^ （从被匹配字符串的开头开始进行匹配）

import re
# ret = re.findall('^h...o','hkslhelloadfas') #从被匹配字符串的开头开始进行匹配
# print(ret)#[]

<3> 元字符：$ （从被匹配字符串的末尾开始进行匹配）

import re
# ret = re.findall('a..x$','sdfalex')#从被匹配字符串的末尾开始进行匹配
# print(ret)#['alex']

<4> 元字符：* （重复匹配：[0,+∞]）

import re
# ret = re.findall('a.*li','adfdalexasli')
# print(ret)#['adfdalexasli']
# ret = re.findall('ba*','afdafbadafbaaaaa')
# print(ret)#['ba', 'baaaaa']

<5> 元字符：+（重复匹配：[1,+∞]）

import re
# ret = re.findall('ab+','afdafdsa')#a后面至少有一个b才能进行匹配
# print(ret)#[]

<6> 元字符：? （重复匹配：[0,1]）

import re
# ret = re.findall('a?b','aaaabhgabdfabfb')#b前面没有a或者一个a才能进行匹配
# print(ret)#['ab', 'ab', 'ab', 'b']

<7> 元字符：{} :（可加匹配范围）

import re
# ret = re.findall('a{5}b','abfdsaaaaabdsa')
# print(ret)#['aaaaab']
# ret = re.findall('a{1,3}b','abfdsaaaaabdsaab')#贪婪匹配  {1，}代表着{1，+∞}
# print(ret)#['ab', 'aaab', 'aab']

总结：*等价于{0，+∞}，+等价于{1，+∞} ，?等价于{0,1}
<8>元字符 ：[ ]（字符集）

impot re
#ret = re.findall('a[c,d,e]x','acx')#可匹配出acx或adx或aex
# ret = re.findall('[a-z]','acx')#可匹配出a-z中的所有字母
# print(ret)#acx

[ ]:还可以取消元字符的特殊功能，但是这三个元字符：\ ^ - 例外

import re
# ret = re.findall('[w,*]','awds*')# 把*在正则中的特殊功能抹去了，只是一个普通字符*
# print(ret)
# ret = re.findall('[0-9,a-z,A-Z]','12tyAs')# - 依旧保持了原来的功能，表示范围
# print(ret)#['1', '2', 't', 'y', 'A', 's']
# ret = re.findall('[^t]','fdsaetdaed')#此时的^,表示取反，即除去t以外的字符全部取出
# print(ret)#['f', 'd', 's', 'a', 'e', 'd', 'a', 'e', 'd']
# ret = re.findall('[^t,a]','fdsae45tdaed')#此时的^,表示取反，即除去t和a以外的字符全部取出
# print(ret)#['f', 'd', 's', 'e', '4', '5', 'd', 'e', 'd']

<9> 元字符 ： \
注意：
反斜杠后边跟元字符去除其特殊功能
反斜杠后边跟普通字符实现特殊功能
例如：
\d: 匹配任何十进制数，它相当于类[0-9]
\D: 匹配任何非数字字符，相当于类[^0-9]
\s：匹配任何空白字符，相当于类[\t\n\r\f\v]
\S：匹配任何非空白字符，相当于类[^\t\n\r\f\v]
\w：匹配任何字母数字字符，相当于类[a-zA-Z0-9]
\W：匹配任何非字母数字字符，相当于类[^a-zA-Z0-9]
\b: 匹配一个特殊字符边界。
示例：

import re
''' 反斜杠后边跟元字符去除其特殊功能 '''
ret = re.findall('a\.','a.gjfdsa%fd')
print(ret)#['a.']
'''反斜杠后边跟普通字符实现特殊功能'''
print(re.findall('\d{11}','afddsafdsaf123045678954fsfda'))
#匹配任何十进制数 ['12304567895']
print(re.findall('\sasd','fasdd asd'))
#[' asd']保证有asd字符串，并且在该字符串的前面有空白字符（空格），输出时，（空格）一并输出
print(re.findall('\w{2}a','afd9affsasd'))
#['d9a', 'fsa']
只要有字符a并且在字符a前面保证有两个任何字母数字字符
print(re.findall(r'I\b','Hello, I Im a LI%T'))
#['I', 'I'] 匹配出单个字符I，并且要求I后面有一个特殊字符，前面的r表示用正则表达式里的语法规则，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略换行字符

注意：由于下面连个原因，在正则表达式中使用反斜杠就会产生一个双重转换的问题。
·Python自身处理字符串是，反斜杠是用于转义字符
·正则表达式也使用反斜杠来表示转义字符

import re
ret = re.findall(r'\\','f\j\gfdd')
print(ret)#['\\', '\\']
'''或者'''
ret = re.findall('\\\\','f\j\gfdd')
print(ret)#['\\', '\\']

为什么在匹配规则中会出现两种情况呢？这是因为，第一种，是在正则表达式的语法规则下进行匹配的；而第二种，是通过Python解释器向正则表达式语法规则转换导致的结果。转换的原则见下图

示例解析：

import re
s = '123\nabc'#表示：123接一个换行符再接abc
# print(s)#123（换行）abc
# print(len(s))#7
# ret1_1 = re.subn('\n','x','123\naffd\ndsa')
# print(ret1_1)#('123xaffdxdsa', 2)
# ret1_2 = re.subn('\\n','x','123\naffd\ndsa')
# print(ret1_2)#匹配规则是一个换行符('123xaffdxdsa', 2)
# ret1_4 = re.subn('\\\\n','x',s)
# print(ret1_4)#匹配规则是一个反斜杠接n ，未能进行匹配('123\nabc', 0)

import re
m = r'123\nabc' #表示：123接 一个反斜杠 再接 nabc
print(m)#123\nabc
print(len(m))#8
m1= r'123\\nabc'
print(m1)#123\\nabc
print(len(m1))#9
ret2_1 = re.subn('\n','x',m)
print(ret2_1)#('123\\nabc', 0)

解析：
由于m = r’123\nabc’，其是表示在正则表达式中的字符串，经过转换，在Python解释器中,实际的字符串应该是’123\nabc’。而，在此行代码re.subn(‘\n’,’x’,m)中，要匹配的是个换行符’\n’，并不能进行匹配，所以最终结果是(‘123\nabc’, 0)

import re
ret2_1_1 = re.subn('\\n','x',m)
print(ret2_1_1)#('123\\nabc', 0)

解析：
re.subn(‘\n’,’x’,m)这行代码中，要匹配的是’\n’,所以也无法匹配。
至于为什么’\n’—>’\n’,是因为re模块和Python解释器之间的转换关系决定的。如要实现替换，该如何呢?见下面的代码

import re
ret2_1_2 = re.subn('\\\\n','x',m)
print(ret2_1_2)#('123xabc', 1)
ret2_2 = re.subn(r'\\n','x',m)
print(ret2_2)#('123xabc', 1)

<10>元字符：( )（分组） |（或）

import re
# print(re.search('(ad)+','dfadads').group())#adad
# print(re.search('(ad)|3','dfad3s').group())#ad
print(re.search('(ad)|3','dfas3s').group())#3
# ret = re.search('(?P<id>\d{3})/(?P<name>\w{3})','www333/ddd')
# print(ret.group())
# print(ret.group('id'))
# print(ret.group('name'))

（2）、正则表达式的处理函数
<1>findall(匹配的正则表达式 , 要匹配的字符串)把匹配到的所有结果返回到一个列表中
<2>search(匹配的正则表达式 , 要匹配的字符串)返回一个对象（object），对象可以调用group()返回结果,返回匹配到的第一个对象。
示例：

import re
# ret = re.search('sb','dsasbdsba')
# print(ret)#<_sre.SRE_Match object; span=(3, 5), match='sb'>
# print(ret.group())#sb

<3>match(匹配的正则表达式 , 要匹配的字符串):只在字符串开始匹配,也返回一个对象（object），对象可以调用group()返回结果,返回匹配到的第一个对象。
示例：

import re
#print(re.match('asd','hgdkasd'))#None
# ret = re.match('asd','asdhhafeasd')
# print(ret)#<_sre.SRE_Match object; span=(0, 3), match='asd'>
# print(ret.group())#asd

<4>split(匹配的正则表达式 , 要匹配的字符串):以匹配的正则表达式为界限，把要匹配的字符串分割，并且不把正则表达式输出
示例：

# ret = re.split('k','djksal')
# print(ret)#['dj', 'sal']
# ret = re.split('[k,s]','djkasl')
# print(ret)#['dj', 'a', 'l']#k，s都没有了

<5>sub( )替换 subn( )也是替换，但会显示替换的次数
示例：

import re print(re.sub('D.*n','hyq','hfalkdDamondfsakfds'))#hfalkdhyqdfsakfds
# print(re.subn('D.{3}n','hyq','hfalkdDamondfsaDamonfdsa'))#('hfalkdhyqdfsahyqfdsa', 2)其中2是指，替换了2次

<6>compile( )编译
示例：

# obj = re.compile('\.com')
# ret = obj.findall('dfjksdjfisd.com')
# print(ret)#['.com']

（3）Demo

# import re
# line = 'Cats are smarter than dogs'
# matchObj = re.match(r'(.*) are (.*?) .*',line, re.M |re.I)
# if matchObj:
#     print('matchObj.group():',matchObj.group())
#     print('matchObj.group(1):',matchObj.group(1))
#     print('matchObj.group(2):',matchObj.group(2))
# else:
#     print('No match!')
# '''
# 解析：
# 首先，这是一个字符串，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个 r 可有可无。
#  (.*) 第一个匹配分组，.* 代表匹配除换行符之外的所有字符。
#  (.*?) 第二个匹配分组，.*? 后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符
#  后面的一个 .* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。
# matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符
# matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的
# matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的
'''