Python（正则 re模块）

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('',res)

res=re.findall("c\\\\l","abc\l")
print('',res)

res=re.findall(r"c\\l","abc\l")
print('',res)

res=re.findall(r"c\\b","abc\br")
print('',res)

res=re.findall("c\bj","abc\bjr")      #\b在ASCII中有特殊含义
print('',res)

res=re.findall(r"c\\bj",r"abc\bjr")
print('',res)

ret=re.findall("李\w+","李a杰,李刚，王超，占山,李连英")  #\w 为什么能匹配汉字?
print('',ret)

ret=re.findall("(李.{1,3}),","李a杰,李刚,王超,占山,李连英,")  # 只显示括号中的内容，但是匹配整个式子
print('',ret)

res=re.findall("c\\b","abcccc\jr   c  c%")
print('',res)
res=re.findall(r"c\b","abcccc\jr   c  c%")
print('',res)
ret=re.findall(r'I\b','I am LIST')
print('',ret)#['I']

res=re.search('a','alvin yuan a,a,a,a')
print('',res)
print('',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('',res)
print('',res.group())
print('',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 ('', '')
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) )等类似公式的计算器程序