python --> 正则表达式

在python中使用正则表达式，需要导入 re 模块

一、 元字符，包括 []  {} | ? * +  .  ^ $ \  ()

　　. 号：通配符，一个点号就代表一个字符，一般情况下不能通配换行符 \n

　　* 号：控制前面的一个字符或是组，重复出现0至n次

　　+号：控制前面的一个字符或是组，重复出现1至n次

　　？号：控制前面的一个字符或是组，重复出现0或1次

　　{}号：内部加数字参数，固定重复次数，也可以写为 {3，5} 代表重复3/4/5次都ok

　　()号：把内部封装一起作为一组，一个整体

　　^号：控制开头

　　$号：控制结尾，

　　\号：后面跟元字符，去掉元字符的特殊含义，后面跟普通字符，赋予普通字符特殊意义，跟数字，引用序号对应的组所匹配到的字符串

　　　　\d：匹配任何十进制数字，相当于类[0-9]

　　　　\D:匹配任何非数字字符，相当于类[^0-9]

　　　　\s:匹配任何空白字符，相当于类[\t\n\r\f\v]

　　　　\S:匹配任何非空字符，相当于类[^\t\n\r\f\v]

　　　　\w:匹配任何字母数字字符，相当于类[0-9a-zA-Z]

　　　　\W:匹配任何非字母数字字符，相当于类[^0-9a-zA-Z]

　　　　\b:匹配一个单词边界，也就是指单词与空格间的位置　　　

　　[]号：字符集，中括号里的内容之间存在或者的关系，取其一；放在字符集里的元字符失去意义，变为普通字符，^放在字符集里表示‘非’的意思；\d等在字符集里意义不变

　　| 号：代表‘或’，选其一

二、函数

　　re.match(pattern,string,flag = 0)：从字符串的开头进行匹配

　　　　flag = 0 参数，可修改为 re.I 使匹配对大小写不敏感；re.S 使可以匹配出任意字符，包括换行符\n；re.M 多行匹配，会影响^ $

　　re.search(pattern,string,flag)：浏览全部字符串，逐个字符匹配，匹配第一个符合规则的字符串

　　match 和 search 匹配的结果都是一个对象，对匹配到的对象进行处理，有如下方法

　　　　.group() 返回匹配到的字符串整体，括号内默认参数为0，如设置为1，则代表返回匹配到的第一组的结果

　　　　.groups() 获取匹配到的分组结果，只匹配pattern里组里的内容，以元组形式显示

　　　　.groupdict() 获取匹配到的结果，以字典形式显示，对于格式有要求，固定格式为 (?P<key名字>value)

 origin = 'hey everybody,say hello to the wonderful world!'
 res = re.search('(?P<key1>h).+(lo)',origin)
 print(res.group(2))
 print(res.group())
 print(res.groups())
 print(res.groupdict())

　　　　.start()返回匹配开始的位置

　　　　.end()返回匹配结束的位置

　　　　.span()返回包含匹配（开始，结束）的位置

origin = 'hey everybody,say hello to the wonderful world!'
res = re.search('(?P<key1>h).+(lo)',origin)
print(res.group(2))
print(res.group())
print(res.groups())
print(res.groupdict())
print(res.start())
print(res.end())
print(res.span())
# 会涉及到正则表达式的贪婪模式，下文讲述

　　re.findall(pattern,string,flag) 将匹配到的所有内容以字符串形式作为元素，放到一个列表中；如果pattern中出现了组，即（），那么就按照所有的限制条件去匹配，但是仅将组里匹配出的内容返回给列表；如果规则里只有1个组，那么得到的列表里元素就是字符串，如果存在多个组，那得到的列表的元素为元组，每个元组的元素是字符串

 import re
 origin = 'hello alex,again alex,bye acd'
 res = re.findall('a(\w*)',origin)
 print(res)
 res = re.findall('a(\w*)x',origin)
 print(res)
 res = re.findall('(a)(\w*)(x)',origin)
 print(res)

 # 结果如下
 ['lex', 'gain', 'lex', 'cd']
 ['le', 'le']
 [('a', 'le', 'x'), ('a', 'le', 'x')]

　　　　几种特别注意情况

　　　　① 嵌套分组括号，执行完一遍外层，再执行一边内层，结果都返回

 import re
 origin = 'ethan'
 res = re.findall('(e)(\w*(a))(n)',origin)
 print(res)

 #结果如下

 [('e', 'tha', 'a', 'n')]

　　　　②判断字符串中空元素个数，得到结果列表元素为空，个数比字符串长度多1

import re
origin = 'ethan'
res = re.findall('',origin)
print(res)

# 结果如下

['', '', '', '', '', ''] 

　　　　③其他特殊情况，涉及分组个数与重复次数

import re
origin = 'ethan'
res = re.findall('(\w)*',origin)
print(res)
n =re.findall('(\dasd)*','1asd2asdp3asd98k3f')
print(n)

# 虽然可以重复0-n次，但是实际分组只有1组，默认返回贪婪模式下最后一组结果

['n', '']
['2asd', '', '3asd', '', '', '', '', '', '']

　　re.sub(pattern,repl,string,max=0) 替换掉字符串内容

　　re.subn() 最后会显示替换掉的次数，结果为元组形式，替换后的字符串为元素

 import re
 origin = 'goodday,goodbye,good morning,oh my god'
 res = re.sub('g\w+d','have',origin)
 print(res)
 res = re.sub('g\w+d','have',origin,3)
 print(res)
 res = re.subn('g\w+d','have',origin)
 print(res)

 #结果如下

 haveay,havebye,have morning,oh my have
 haveay,havebye,have morning,oh my god
 ('haveay,havebye,have morning,oh my have', 4)

　　re.split(pattern,string,maxsplit,flag) 按规则分割字符串

　　　　①分割规则里不包含组，那么分割出的结果里不包含分割规则 ②分割规则里包含组，那么分割出来的结果会包含组内容 ③如果分割规则处在string末尾或开始，那么会包含空内容成为元素

 import re
 origin = 'one1two2three3'
 res = re.split('\d+',origin)
 print(res)

 stri = 'nice to meet you ethan,but goodbye now'
 res = re.split('e(\w+)an',stri)
 print(res)
 res = re.split('ethan',stri)
 print(res)

 #结果如下

 ['one', 'two', 'three', '']
 ['nice to meet you ', 'th', ',but goodbye now']
 ['nice to meet you ', ',but goodbye now']

　　re.compile(pattern,flags) 将规则编译到obj里，下次再使用此规则时直接调用obj的方法，适用于重复多次使用的规则

 import re
 obj = re.compile('e(\w+)n')
 origin = 'nice to see you ethan,but byebye now'
 res = obj.findall(origin)
 print(res)
 res = obj.split(origin)
 print(res)

 #结果如下

 ['tha']
 ['nice to see you ', 'tha', ',but byebye now']

　　re.finditer(pattern,string,flags) 生成迭代对象，需要进行for循环，才能得到对象，需要对象的.group(),.groups(),.groupdict()的方法得到具体值

 import re
 rigin = 'alex,goodday'
 res = re.finditer('a(\w*)(?P<key1>x)',origin)
 print(res)
 for i in res:
     print(i,i.group(),i.groups(),i.groupdict())

 # 结果如下
 <callable_iterator object at 0x000000DA49F7CB38>
 <_sre.SRE_Match object; span=(0, 4), match='alex'> alex ('le', 'x') {'key1': 'x'}

三、贪婪模式与非贪婪模式
　　默认情况下，所有匹配均为贪婪模式，除非对匹配方式进行了设置，例如

 import re
 origin = 'a23018319cdnk'
 res = re.search('a(\d+)',origin).group()
 print(res)
 res = re.search('a(\d+?)',origin).group()
 print(res)

 #显示结果如下
 a23018319
 a2

　　但是在组两边都有限制条件的时候，非贪婪模式也会失效，例如

import re
res = re.search('a(\d+?)',origin).group()
print(res)
res = re.search('a(\d+?)c',origin).group()
print(res)

#结果如下

a2
a23018319c

四、原生字符r ,使用时表示在python中存在特殊意义的字符，失去特殊意义，只体现其普通意义，而re模块中的则不受影响