|
1. 匹配一个字符 |
表达式 |
说明 |
等价表达式 |
|
d |
数字 |
[0-9] |
|
|
w |
字母、数字、下划线 |
[a-zA-Z0-9_] |
|
|
. |
除换行外任意字符 |
|
|
|
s |
空格 |
[ fv] |
|
|
D |
除数字 |
|
|
|
W |
除字母、数字、下划线 |
|
|
|
S |
除空格 |
|
|
|
2. 集合 |
[abc][a-g] |
[]指一个集合，匹配[]中的任意一个 |
|
|
[^A] |
^在集合[]开头，匹配除A以外字符 |
||
|
A|B |
匹配A或B表达式 |
||
|
(A) |
()指一个组，匹配A中所有内容 |
||
|
3. 重复 |
a? |
贪心地匹配a 0次或1次（贪心表示尽可能多地） |
|
|
a{m, n} |
信心地匹配a m-n次。{,n}：0-n次 {m,}：m-无限次 |
||
|
a* |
贪心地匹配a 0-无限次 |
||
|
a+ |
贪心地匹配a 1-无限次 |
||
|
a?? a*? a+? a{m,n}? |
尽可能少地匹配 |
||
|
4. 匹配位置 |
^... |
要求匹配给定串的开头 |
|
|
...$ |
要求匹配给定串的结尾 |
||
|
... |
匹配单词边界，匹配成功要求A匹配到给定串的边界 |
||
|
使用时模式串要用r，因为还有其它意义 |
|||
|
...B |
匹配单词非边界 |
||
|
A... |
要求匹配给定串的开头 |
||
|
... |
要求匹配给定串的结尾 |
re模块
就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
字符匹配（普通字符，元字符）：
1 普通字符：大多数字符和字母都会和自身匹配
>>> re.findall('alvin','yuanaleSxalexwupeiqi')
['alvin']
2 元字符：. ^ $ * + ? { } [ ] | ( )
元字符
. ^ $
import re
ret1=re.findall('李.','李爽
alex
李四
egon
alvin
李二') #。除换行符（
）之外的任意一个字符
ret2=re.findall('^李.','李爽
alex
李四
egon
alvin
李二') # ^ 匹配开头字符
ret3=re.findall('李.$','李爽
alex
李四
egon
alvin
李二') # $ 匹配末尾字符串
* + ? { }
import re
ret1=re.findall('李.*','李杰
alex
李莲英
egon
alvin
李二棍子') # * （0，无穷）
ret2=re.findall('李.+','李杰
alex
李莲英
egon
alvin
李二棍子') # + （1，无穷）
ret3=re.findall('(李.{1,2})
','李杰
alex
李莲英
egon
alvin
李二棍子') # 设定优先级的原因
# 匹配一个数字包括整型和浮点型
ret4=re.findall('d+.?d*','12.45,34,0.05,109') # ？ （0,1）
print(ret4)
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
ret=re.findall('131d+?','1312312312')
print(ret) ['1312']
转义符
1、反斜杠后边跟元字符去除特殊功能,比如.
2、反斜杠后边跟普通字符实现特殊功能,比如d
d 匹配任何十进制数； 它相当于类 [0-9]。 D 匹配任何非数字字符； 它相当于类 [^0-9]。 s 匹配任何空白字符； 它相当于类 [ fv]。 S 匹配任何非空白字符； 它相当于类 [^ fv]。 w 匹配任何字母数字字符； 它相当于类 [a-zA-Z0-9_]。 W 匹配任何非字母数字字符； 它相当于类 [^a-zA-Z0-9_] 匹配一个特殊字符边界，比如空格 ，&，＃等
让我们看一下的应用：
ret=re.findall(r'I','I am LIST') print(ret)#['I']
接下来我们试着匹配下“abcle”中的‘cl’:
import re
ret=re.findall('cl','abcle')
print(ret)#[]
ret=re.findall('c\l','abcle')
print(ret)#[]
ret=re.findall('c\\l','abcle')
print(ret)#[]
ret=re.findall(r'c\l','abcle')
print(ret)#[]
# 是特殊符号所以,'abce'前面需要加r
ret=re.findall(r'c\b',r'abce')
print(ret)#[]
分组 ()
m = re.findall(r'(ad)+', 'add')
print(m)
ret=re.search('(?P<id>d{2})/(?P<name>w{3})','23/com')
print(ret.group())#23/com
print(ret.group('id'))#23
元字符之｜
ret=re.search('(ab)|d','rabhdg8sd')
print(ret.group())#ab
字符集［］
#--------------------------------------------字符集[]
ret=re.findall('a[bc]d','acd')
print(ret)#['acd']
ret=re.findall('[a-z]','acd')
print(ret)#['a', 'c', 'd']
ret=re.findall('[.*+]','a.cd+')
print(ret)#['.', '+']
#在字符集里有功能的符号: - ^ （范围、非（非的是整个方括号内的东西）、转译）
ret=re.findall('[1-9]','45dha3')
print(ret)#['4', '5', '3']
ret=re.findall('[^ab]','45bdha3')
print(ret)#['4', '5', 'd', 'h', '3']
ret=re.findall('[d]','45bdha3')
print(ret)#['4', '5', '3']
贪婪匹配
贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配
string pattern1 = @"a.*c"; // greedy match
Regex regex = new Regex(pattern1);
regex.Match("abcabc"); // return "abcabc"
非贪婪匹配：在满足匹配时，匹配尽可能短的字符串，使用?来表示非贪婪匹配
string pattern1 = @"a.*?c"; // non-greedy match
Regex regex = new Regex(pattern1);
regex.Match("abcabc"); // return "abc"
几个常用的非贪婪匹配Pattern
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
.*?的用法：
-------------------------------- . 是任意字符 * 是取 0 至 无限长度 ? 是非贪婪模式。 何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在： .*?a 就是取前面任意长度的字符，到底一个 a 出现
re模块下的常用方法
import re re.findall('a','alvin yuan') #返回所有满足匹配条件的结果,放在列表里 re.search('a','alvin yuan').group() #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以 # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。 re.match('a','abc').group() #同search,不过尽在字符串开始处进行匹配 ret=re.split('[ab]','abcd') #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
ret=re.split('d+','ab12cd34asdf') #结果中只有字母，用于分割的数字都不在了
ret=re.split('(d+)',s) #用于分割的数字也在结果中 print(ret)#['', '', 'cd'] ret=re.sub('d','abc','alvin5yuan6',1) #替换，指定替换次数 ret=re.subn('d','abc','alvin5yuan6') #替换，以及替换次数 obj=re.compile('d{3}') #规则 #编译 ret=obj.search('abc123eeee') #字符串 #方便多次匹配 print(ret.group())#123 import re ret=re.finditer('d','ds3sy4784a') #得到的的是一个迭代器，是一个个对象，需要next group 不断取值。 print(ret) #<callable_iterator object at 0x10195f940> print(next(ret).group()) print(next(ret).group())
注意：
findall的优先级查询：
import re
ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)#['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com') #？：取消优先级
print(ret)#['www.oldboy.com']
2 split的优先级查询
ret=re.split("d+","yuan2egon56alex") #不显示用于分割的数字
print(ret)
ret=re.split("(d+)","yuan2egon56alex") #显示用于分割的数字
print(ret)
例：
import re res=re.findall('.com','www.baidu.com,www.douban|com') print('1',res) res=re.findall("c\\l","abcl") print('2',res)
res=re.findall(r"c\l","abcl") print('3',res) res=re.findall(r"c\b","abcr") print('4',res) res=re.findall("cj","abcjr") #在ASCII中有特殊含义 print('5',res) res=re.findall(r"c\bj",r"abcjr") print('6',res) ret=re.findall("李w+","李a杰,李刚，王超，占山,李连英") #w 为什么能匹配汉字? print('7',ret) ret=re.findall("(李.{1,3}),","李a杰,李刚,王超,占山,李连英,") # 只显示括号中的内容，但是匹配整个式子 print('8',ret) res=re.findall("c\b","abccccjr c c%") print('9',res) res=re.findall(r"c","abccccjr c c%") print('10',res) ret=re.findall(r'I','I am LIST') print('11',ret)#['I'] res=re.search('a','alvin yuan a,a,a,a') print('12',res) print('12',res.group()) res=re.search(r"aaaaa-bbbbb-ddddd-(?P<year>20[01]d)-(?P<month>d)+-(?P<day>d+)","aaaaa-bbbbb-ddddd-2017-09-33") #有名分组 print('13',res) print('13',res.group()) print('13',res.group('year','day')) print(eval('1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'))
结果如下： D:Python36python.exe D:/py/empty/empty6.py 1 ['.com'] 2 ['c\l'] 3 ['c\l'] 4 [] 5 ['cx08j'] 6 ['c\bj'] 7 ['李a杰', '李刚', '李连英'] 8 ['李a杰', '李刚', '李连英'] 9 ['c', 'c', 'c'] 10 ['c', 'c', 'c'] 11 ['I'] 12 <_sre.SRE_Match object; span=(0, 1), match='a'> 12 a 13 <_sre.SRE_Match object; span=(0, 28), match='aaaaa-bbbbb-ddddd-2017-09-33'> 13 aaaaa-bbbbb-ddddd-2017-09-33 13 ('2017', '33') 2776672.6952380957 Process finished with exit code 0
练习
1、匹配标签
import re print(re.findall("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>")) print(re.search("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>")) print(re.search(r"<(w+)>w+</1>","<h1>hello</h1>"))
2、匹配整数
#匹配出所有的整数 import re #ret=re.findall(r"d+{0}]","1-2*(60+(-40.35/5)-(-4*3))") ret=re.findall(r"-?d+.d*|(-?d+)","1-2*(60+(-40.35/5)-(-4*3))") ret.remove("") print(ret)
3、其它练习
1、 匹配一段文本中的每行的邮箱 2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’； 分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、 一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$ 3、 匹配一段文本中所有的身份证数字。 4、 匹配qq号。(腾讯QQ号从10000开始) ［1,9］[0,9]{4,} 5、 匹配一个浮点数。 ^(-?d+)(.d+)?$ 或者 -?d+.?d* 6、 匹配汉字。 ^[u4e00-u9fa5]{0,}$ 7、 匹配出所有整数
4、爬虫练习
import requests import re import json def getPage(url): response=requests.get(url) return response.text def parsePage(s): com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>d+).*?<span class="title">(?P<title>.*?)</span>' '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>',re.S) ret=com.finditer(s) for i in ret: yield { "id":i.group("id"), "title":i.group("title"), "rating_num":i.group("rating_num"), "comment_num":i.group("comment_num"), } def main(num): url='https://movie.douban.com/top250?start=%s&filter='%num response_html=getPage(url) ret=parsePage(response_html) print(ret) f=open("move_info7","a",encoding="utf8") for obj in ret: print(obj) data=json.dumps(obj,ensure_ascii=False) f.write(data+" ") if __name__ == '__main__': count=0 for i in range(10): main(count) count+=25
作业
实现能计算类似 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式的计算器程序