re模块正则表达式

weixin_30607659

于 2019-02-03 18:46:00 发布

阅读量109

点赞数

原文链接：http://www.cnblogs.com/joneylulu/p/10350820.html

版权

正则表达式就是字符串的匹配规则，在多数编程语言里都有相应的支持，python里对应的模块是re。

 1 #请从以下文件里取出所有的手机号
 2 
 3 姓名       地区    身高   体重    电话
 4 况咏蜜     北京    171    48    13651054608
 5 王心颜     上海    169    46    13813234424
 6 马纤羽     深圳    173    50    13744234523
 7 乔亦菲     广州    172    52    15823423525
 8 罗梦竹     北京    175    49    18623423421
 9 刘诺涵     北京    170    48    18623423765
10 岳妮妮     深圳    177    54    18835324553
11 贺婉萱     深圳    174    52    18933434452
12 叶梓萱     上海    171    49    18042432324
13 杜姗姗     北京    167    49    13324523342
14 
15 
16 #解决方法
17 # f = open("嫩模联系方式.txt",'r',encoding="gbk")
18 #
19 # contacts = []
20 # for line in f:
21 #     name,region,height,weight,phone = line.split()
22 #     if phone.isdigit():
23 #         #print(phone)
24 #         contacts.append(phone)
25 # print(contacts)
26 #结果为：['13651054608', '13813234424', '13744234523', '15823423525', '18623423421', '18623423765', '18835324553', '18933434452', '18042432324', '13324523342']
27 
28 
29 # re 正则表达式
30 import re
31 f = open("嫩模联系方式.txt",'r',encoding="gbk")
32 data = f.read()
33 print(re.search("[0-9]{11}",data))
34 # 结果为：<re.Match object; span=(58, 69), match='13651054608'>
35 
36 print(re.findall("[0-9]{11}",data))
37 #结果为：['03651054608', '13813234424', '13744234523', '15823423525', '18623423421', '18623423765', '18835324553', '18933434452', '18042432324', '13324523342']
38 
39 print(re.findall("1[0-9]{10}",data))
40 #结果为：['13813234424', '13744234523', '15823423525', '18623423421', '18623423765', '18835324553', '18933434452', '18042432324', '13324523342']

常用模块学习—re 匹配语法

常用的表达式规则

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾， 若指定flags MULTILINE ,re.search('foo.$','foo1\nfoo2\n',re.MULTILINE).group() 会匹配到foo1
'*'     匹配*号前的字符0次或多次， re.search('a*','aaaabac')  结果'aaaa'
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次 ,re.search('b?','alex').group() 匹配b 0次
'{m}'   匹配前一个字符m次 ,re.search('b{3}','alexbbbs').group()  匹配到'bbb'
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配， re.search("(abc){2}a(123|45)", "abcabca456c").group() 结果为'abcabca45'


'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的，相当于re.match('abc',"alexabc") 或^
'\Z'    匹配字符结尾，同$ 
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
'\s'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

re的匹配语法有以下几种
- re.match 从头开始匹配
- re.search 匹配包含
- re.findall 把所有匹配到的字符放到以列表中的元素返回
- re.split 以匹配到的字符当做列表分隔符
- re.sub 匹配字符并替换
- re.fullmatch 全部匹配

import re

#re.match     从头开始匹配
#查找里面所有的数字：
s = 'abc1d3e'
print(re.match('[0-9]',s))            #结果为：None
s1 = '1abc1d3e'
print(re.match('[0-9]',s1))           #结果为：<re.Match object; span=(0, 1), match='1'>


#re.search    匹配包含
#查找里面所有的数字：
s = 'abc1d3e'
print(re.search('[0-9]',s))           #结果为：<re.Match object; span=(3, 4), match='1'>   （对象）  span指索引

s = 'abc1d3e'
match_res = re.search('[0-9]',s)
if match_res:　　　　　　　　　　　　　　　#先判断是否能拿到值，取值的方法 .group()　　　　　
    print(match_res.group())           #结果为：1   


#re.findall   把所有匹配到的字符当做列表分隔符
#查找里面所有的数字：
s = 'abc1d3e'
print(re.findall('[0-9]',s))          #结果为：['1', '3']

常用模块学习—re 正则表达式公式讲解1

import re

# '.'     默认匹配除\n之外的任意一个字符
s = 'abc1d3e'
print(re.search('.',s))               #结果为：<re.Match object; span=(0, 1), match='a'>
s ='1asd'
print(re.search('.',s))               #结果为：<re.Match object; span=(0, 1), match='1'>
s ='~asd'
print(re.search('.',s))               #结果为：<re.Match object; span=(0, 1), match='~'>
s ='*asd'
print(re.search('.',s))               #结果为：<re.Match object; span=(0, 1), match='*'>
print(re.search('..',s))              #结果为：<re.Match object; span=(0, 2), match='*a'>
print(re.match('..',s))               #结果为：<re.Match object; span=(0, 2), match='*a'>


# '^'     匹配字符开头
s = 'abc1d3e'
print(re.search('^a',s))              #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('^ab',s))             #结果为：<re.Match object; span=(0, 2), match='ab'>
print(re.search('^b',s))              #结果为：None
print(re.match('ab',s))               #结果为：<re.Match object; span=(0, 2), match='ab'>


#'$'     匹配字符结尾
s = 'abc1d3e'
print(re.search('e$',s))              #结果为：<re.Match object; span=(6, 7), match='e'>
print(re.search('3$',s))              #结果为：None
s = 'bob'
print(re.match('b$',s))               #结果为：None        match 以b开头，以b结尾
s = 'bb'
print(re.match('b$',s))               #结果为：None
s = 'b'
print(re.match('b$', s))              #结果为：<re.Match object; span=(0, 1), match='b'>

常用模块学习—re 正则表达式公式讲解2

import re

# '*'     匹配*号前的字符0次或多次
print(re.search('a*','Alex'))              #结果为：<re.Match object; span=(0, 0), match=''>
print(re.search('a*','Alex').group())      #结果为：
print(re.search('a*','alex'))              #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('a*','aaaaaalex'))        #结果为：<re.Match object; span=(0, 6), match='aaaaaa'>
print(re.search('ab*','aaaaaalex'))       #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('ab*','abaaaalex'))       #结果为：<re.Match object; span=(0, 2), match='ab'>
print(re.search('ab*','ababaalex'))       #结果为：<re.Match object; span=(0, 2), match='ab'>
print(re.search('ab*','abbaaalex'))       #结果为：<re.Match object; span=(0, 3), match='abb'>   


# '+'     匹配前一个字符1次或多次
print(re.search('a','abbaaalex'))           #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('a+','abbaaalex'))          #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('a+','sdg'))                 #结果为：None
print(re.search('a+','aaab'))                #结果为：<re.Match object; span=(0, 3), match='aaa'>
print(re.search('.+','aaab'))                #结果为：<re.Match object; span=(0, 4), match='aaab'>
print(re.search('ab+','aaabbb'))            #结果为：<re.Match object; span=(2, 6), match='abbb'>
print(re.search('ab+','aaabab'))            #结果为：<re.Match object; span=(2, 4), match='ab'>

# '?'     匹配前一个字符1次或0次
print(re.search('a?','aaabbb'))             #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('a?','ddd'))                 #结果为：<re.Match object; span=(0, 0), match=''>

# '{m}'   匹配前一个字符m次
print(re.search('a{2}','adddad'))            #结果为：None
print(re.search('a{2}','adddaad'))           #结果为：<re.Match object; span=(4, 6), match='aa'>
print(re.search('a{2}','adddaaad'))          #结果为：<re.Match object; span=(4, 6), match='aa'>
print(re.search('.{2}','addaaad'))           #结果为：<re.Match object; span=(0, 2), match='ad'>
print(re.search('[0-9]{2}','addaaad'))       #结果为：None
print(re.search('[0-9]{2}','addaaad23'))     #结果为：<re.Match object; span=(7, 9), match='23'>
print(re.search('[0-9]{2}','addaaad2345'))   #结果为：<re.Match object; span=(7, 9), match='23'>

#'{n,m}' 匹配前一个字符n到m次
print(re.search('[a-z]','alex'))              #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('[a-z]{2}','alex'))           #结果为：<re.Match object; span=(0, 2), match='al'>
print(re.search('[a-z]{1,2}','alex'))         #结果为：<re.Match object; span=(0, 2), match='al'>
print(re.search('[a-z]{1,2}','a2lex'))        #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('[a-z]{1,2}','2lex'))         #结果为：<re.Match object; span=(1, 3), match='le'>
print(re.search('[a-z]{1,10}','2lex'))        #结果为：<re.Match object; span=(1, 4), match='lex'>

# '|'     匹配|左或|右的字符
print(re.search('alex|Alex','Alex'))         #结果为：<re.Match object; span=(0, 4), match='Alex'>
print(re.search('alex|Alex','alex'))         #结果为：<re.Match object; span=(0, 4), match='alex'>
print(re.search('a|Alex','alex'))            #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('[a|A]lex','alex'))          #结果为：<re.Match object; span=(0, 4), match='alex'>
print(re.search('[a|A]lex','Alex'))          #结果为：<re.Match object; span=(0, 4), match='Alex'>
print(re.search('[a|A]lex','asdAlex'))       #结果为：<re.Match object; span=(3, 7), match='Alex'>
print(re.search('^[a|A]lex','asdAlex'))      #结果为：None
print(re.search('[a|A]lex$','asdAlex'))      #结果为：<re.Match object; span=(3, 7), match='Alex'>

常用模块学习—re 正则表达式公式讲解3

import re

#group()在正则表达式中用于获取分段截获的字符串
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))      #结果为：123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))      #结果为：123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))      #结果为：abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))      #结果为：456

# '(...)' 分组匹配
print(re.search('[a-z]+','alex123'))                       #结果为：<re.Match object; span=(0, 4), match='alex'>
print(re.search('[a-z]+[0-9]+','alex123'))                #结果为：<re.Match object; span=(0, 7), match='alex123'>
print(re.search('[a-z]+[0-9]+','alex123').group())        #结果为：alex123
print(re.search('([a-z]+)([0-9]+)','alex123'))            #结果为：<re.Match object; span=(0, 7), match='alex123'>
print(re.search('([a-z]+)([0-9]+)','alex123').group())    #结果为：alex123
print(re.search('([a-z]+)([0-9]+)','alex123').groups())   #结果为：('alex', '123')

# '\A'    只从字符开头匹配
print(re.search('\Aabc','alexabc'))                       #结果为：None
#相当于
print(re.match('abc','alexabc'))                          #结果为：None
print(re.search('\Aalex','alex'))                         #结果为：<re.Match object; span=(0, 4), match='alex'>
print(re.search('\AAlex','Alex'))                         #结果为：<re.Match object; span=(0, 4), match='Alex'>

# '\Z'    匹配字符结尾，同$
print(re.search('alex\Z','duedalex'))                    #结果为：<re.Match object; span=(4, 8), match='alex'>
print(re.search('2\Z','alex2'))                           #结果为：<re.Match object; span=(4, 5), match='2'>

# '\d'    匹配数字0-9
print(re.search('[0-9]','alex2'))                         #结果为：<re.Match object; span=(4, 5), match='2'>
print(re.search('\d','alex2'))                            #结果为：<re.Match object; span=(4, 5), match='2'>
print(re.search('\d+','alex2'))                           #结果为：<re.Match object; span=(4, 5), match='2'>
print(re.search('\d+','alex32342355'))                   #结果为：<re.Match object; span=(4, 12), match='32342355'>
print(re.search('\d+','alex32342dd3'))                   #结果为：<re.Match object; span=(4, 9), match='32342'>

# '\D'    匹配非数字
print(re.search('\D','alex2342d'))                       #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('\D+','alex34d2S'))                      #结果为：<re.Match object; span=(0, 4), match='alex'>
print(re.search('\D+','a@#$^lex344'))                    #结果为：<re.Match object; span=(0, 8), match='a@#$^lex'>

# '\w'    匹配[A-Za-z0-9]
print(re.search('\w','alex2443dxd44'))                  #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('\w+','alex2443dxd44'))                 #结果为：<re.Match object; span=(0, 13), match='alex2443dxd44'>
print(re.search('\w+','alex2443dx-d44'))                #结果为：<re.Match object; span=(0, 10), match='alex2443dx'>

# '\W'    匹配非[A-Za-z0-9]
print(re.search('\W','alex2443dx-d44'))                #结果为：<re.Match object; span=(10, 11), match='-'>
print(re.search('\W+','a@#$^lex344'))                   #结果为：<re.Match object; span=(1, 5), match='@#$^'>

# '\s'     匹配空白字符、\t、\n、\r
s = 'alex\njack'
print(s)
#结果为：
# alex
#jack
print(re.search('\s',s))                                 #结果为：<re.Match object; span=(4, 5), match='\n'>
s = 'alex\njack\tadd\rmack'
print(re.findall('\s',s))                                #结果为：['\n', '\t', '\r']
print(re.search('\s+',s))                                #结果为：<re.Match object; span=(4, 5), match='\n'>

#'(?P<name>...)' 分组匹配
s = '130704200005250613'
print(s)                                                 #结果为：130704200005250613
print(re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s))           #结果为：<re.Match object; span=(0, 10), match='1307042000'>
print(re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s).groups())  #结果为：('130', '704', '2000')
res = re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s)
print(res.groupdict())                                   #结果为：{'province': '130', 'city': '704', 'born_year': '2000'}

常用模块学习—re 正则表达式公式讲解4

import re

# re.split 以匹配到的字符当做列表分隔符（maxsplit 指定替换次数）
s = 'alex22jack23rain31jinxin50'
print(s.split())                               #结果为：['alex22jack23rain31jinxin50']
print(s.split('[0-9]'))                       #结果为：['alex22jack23rain31jinxin50']
print(re.split('\d',s))                       #结果为：['alex', '', 'jack', '', 'rain', '', 'jinxin', '', '']    d指代表1个数字，22,23有两个数字，所以这里有个空格
print(re.split('\d+',s))                      #结果为：['alex', 'jack', 'rain', 'jinxin', '']　　　　　　　　　　　　d+代表多个数字
print(re.findall('\d+',s))                    #结果为：['22', '23', '31', '50']

s = 'alex22jack23rain31jinxin50#mack-oldboy'
print(re.split('\d+|#|-',s))                 #结果为：['alex', 'jack', 'rain', 'jinxin', '', 'mack', 'oldboy']

#转义（前面加'\'）
s = 'alex22jack23rain31jinxin50|mack-oldboy'
print(re.split('\d+|\||-',s))               #结果为：['alex', 'jack', 'rain', 'jinxin', '', 'mack', 'oldboy']

s = 'alex22jack23rain31\\jinxin50|mack-oldboy'
print(s)                                     #结果为：alex22jack23rain31\jinxin50|mack-oldboy
print(re.split('\\\\',s))                   #结果为：['alex22jack23rain31', 'jinxin50|mack-oldboy']

s='9-2*5/3+7/3*99/4*2998+10*568/14'
print(s)                                     #结果为：9-2*5/3+7/3*99/4*2998+10*568/14
print(re.split('[\+\-\*\/]',s))            #结果为：['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']
print(re.split('[\+\-\*\/]',s,maxsplit=3)) #结果为：['9', '2', '5', '3+7/3*99/4*2998+10*568/14']


# re.sub 匹配字符并替换（count 指定替换次数）
s = 'alex22jack23rain31\\jinxin50|mack-oldboy'
print(re.sub('\d+','_',s))                  #结果为：alex_jack_rain_\jinxin_|mack-oldboy
print(re.sub('\d+','_',s,count=2))          #结果为：alex_jack_rain31\jinxin50|mack-oldboy

常用模块学习—re 正则表达式公式讲解5

import re

# re.fullmatch 全部匹配
print(re.fullmatch('alex','alex123'))                                      #结果为：None
print(re.fullmatch('alex124','alex123'))                                  #结果为：None
print(re.fullmatch('alex123','alex123'))                                  #结果为：<re.Match object; span=(0, 7), match='alex123'>

#邮箱
print(re.fullmatch('\w+@\w+\.(com|cn|edu)','alex@oldboyedu.cn'))         #结果为：<re.Match object; span=(0, 17), match='alex@oldboyedu.cn'>
print(re.fullmatch('\w+@\w+\.(com|cn|edu)','alex@oldboyedu.com'))        #结果为：<re.Match object; span=(0, 18), match='alex@oldboyedu.com'>
print(re.fullmatch('\w+@\w+\.(com|cn|edu)','alex@oldboyedu.edu'))        #结果为：<re.Match object; span=(0, 18), match='alex@oldboyedu.edu'>


#re.compile(pattern, flags=0)
#语法（compile的作用：先写入到内存中，当大量调用的时候会节省时间）
pattern = re.compile('\\w+@\\w+\\.(com|cn|edu)')
print(pattern)                                                #结果为：re.compile('\\w+@\\w+\\.(com|cn|edu)')
print(pattern.fullmatch('alex@oldboyedu.cn'))              #结果为：<re.Match object; span=(0, 17), match='alex@oldboyedu.cn'>

'''
小结：
Python 解释器将公式转换成逻辑的判断语句，是需要时间的
complie 的作用是一次翻译后，直接调用即可，提高效率
fullmatch 是每次需要单独翻译，会浪费时间
'''

常用模块学习—re 正则表达式公式讲解6

Flags标志

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为
S(DOTALL): 改变'.'的行为,make the '.' special character match any character at all, including a newline; without this flag, '.' will match anything except a newline.
X(re.VERBOSE) 可以给你的表达式写注释，使其更可读，下面这2个意思一样

常用模块学习—re 正则表达式公式讲解7

import re

#re.I(re.IGNORECASE): 忽略大小写
print(re.search('a','alex'))                 #结果为：<re.Match object; span=(0, 1), match='a'>
print(re.search('a','Alex'))                 #结果为：None
print(re.search('a','Alex',re.I))            #结果为：<re.Match object; span=(0, 1), match='A'>

#re.M(MULTILINE): 多行模式，改变'^'和'$'的行为
print(re.search('foo.$','foo1\nfoo2\n'))      #结果为：<re.Match object; span=(5, 9), match='foo2'>
print(re.search('foo.$','foo1\nfoo2\n',re.M)) #结果为：<re.Match object; span=(0, 4), match='foo1'>  匹配这一行的结尾

#re.S(DOTALL): 改变'.'的行为       '.'  默认匹配除\n之外的任意一个字符
print(re.search('.','\n'))                      #结果为：None
print(re.search('.','\n',re.S))                 #结果为：<re.Match object; span=(0, 1), match='\n'>

#re.X(re.VERBOSE) 可以给你的表达式写注释，使其更可读
print(re.search('. #test','alex'))             #结果为：None
print(re.search('. #test','alex',re.X))         #结果为：<re.Match object; span=(0, 1), match='a'>

用模块学习—练习题

import re


#验证手机号是否合法
phone_legal = re.compile('^(13\d|14[5|7]|15\d|166|17\d|18\d)\d{8}$')
while True:
    phone = input('请输入您的手机号：')
    res = re.search(phone_legal,phone)
    if res:
        print('此手机号合法')
    else:
        print('此手机号不合格')



#验证邮箱是否合法
Email_legal = re.compile('\w+@\w+\\.(com|cn|edu|mobi|org)')
while True:
    Email = input('请输入您的邮箱：')
    res = re.search(Email_legal,Email)
    if res:
        print('此邮箱合法')
    else:
        print('此邮箱不合法')