1. 匹配一个字符 |
表达式 |
说明 |
等价表达式 |
\d |
数字 |
[0-9] |
|
\w |
字母、数字、下划线 |
[a-zA-Z0-9_] |
|
. |
除换行外任意字符 |
|
|
\s |
空格 |
[\t\n\r\f\v] |
|
\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. 匹配位置 |
^... |
要求匹配给定串的开头 |
|
...$ |
要求匹配给定串的结尾 |
||
...\b |
匹配单词边界，匹配成功要求A匹配到给定串的边界 |
||
使用时模式串要用r，因为\b还有其它意义 |
|||
...\B |
匹配单词非边界 |
||
\A... |
要求匹配给定串的开头 |
||
...\Z |
要求匹配给定串的结尾 |
re模块
就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
字符匹配（普通字符，元字符）：
1 普通字符：大多数字符和字母都会和自身匹配
>>> re.findall('alvin','yuanaleSxalexwupeiqi')
['alvin']
2 元字符：. ^ $ * + ? { } [ ] | ( ) \
元字符
. ^ $
import re
ret1=re.findall('李.','李爽\nalex\n李四\negon\nalvin\n李二') #。除换行符（\n）之外的任意一个字符
ret2=re.findall('^李.','李爽\nalex\n李四\negon\nalvin\n李二') # ^ 匹配开头字符
ret3=re.findall('李.$','李爽\nalex\n李四\negon\nalvin\n李二') # $ 匹配末尾字符串
* + ? { }
import re
ret1=re.findall('李.*','李杰\nalex\n李莲英\negon\nalvin\n李二棍子') # * （0，无穷）
ret2=re.findall('李.+','李杰\nalex\n李莲英\negon\nalvin\n李二棍子') # + （1，无穷）
ret3=re.findall('(李.{1,2})\n','李杰\nalex\n李莲英\negon\nalvin\n李二棍子') # 设定优先级的原因
# 匹配一个数字包括整型和浮点型
ret4=re.findall('\d+\.?\d*','12.45,34,0.05,109') # ？ （0,1）
print(ret4)
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
ret=re.findall('131\d+?','1312312312')
print(ret) ['1312']
转义符 \
1、反斜杠后边跟元字符去除特殊功能,比如\.
2、反斜杠后边跟普通字符实现特殊功能,比如\d
\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 匹配一个特殊字符边界，比如空格 ，&，＃等
让我们看一下\b的应用：
ret=re.findall(r'I\b','I am LIST')
print(ret)#['I']
接下来我们试着匹配下“abc\le”中的‘c\l’:
import re
ret=re.findall('c\l','abc\le')
print(ret)#[]
ret=re.findall('c\\l','abc\le')
print(ret)#[]
ret=re.findall('c\\\\l','abc\le')
print(ret)#[]
ret=re.findall(r'c\\l','abc\le')
print(ret)#[]
# \b是特殊符号所以,'abc\be'前面需要加r
ret=re.findall(r'c\\b',r'abc\be')
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","abc\l")
print('2',res)
res=re.findall(r"c\\l","abc\l")
print('3',res)
res=re.findall(r"c\\b","abc\br")
print('4',res)
res=re.findall("c\bj","abc\bjr") #\b在ASCII中有特殊含义
print('5',res)
res=re.findall(r"c\\bj",r"abc\bjr")
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","abcccc\jr c c%")
print('9',res)
res=re.findall(r"c\b","abcccc\jr c c%")
print('10',res)
ret=re.findall(r'I\b','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:\Python36\python.exe D:/py/empty/empty6.py
1 ['.com']
2 ['c\\l']
3 ['c\\l']
4 []
5 ['c\x08j']
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+"\n")
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) )等类似公式的计算器程序