Python（正则 re模块）

                 

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) )等类似公式的计算器程序