5-5 re模块 正则表达式

1，正则表达式

正则表达式，就是匹配字符串内容的一种规则。

官方定义：正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

字符组 ： [字符组]
在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。

字符组只能匹配一个元素。字符组代表一个字符位置上可以出现的所有内容。范围是根据asc码来的，范围必须是从小到大的指向，一个字符组可以有多个范围。

[0-9]    匹配0到9的整数
[1-9][0-9][0-9]   匹配三位数
[a-z]小写字母
[A-Z]大写字母
[A-Za-z]大小写字母
[0-9a-fA-F]用来验证16进制字符

字符:在正则表达式中有特殊意义。

. 点匹配除换行符(enter)回车键以为的任意字符
\w 匹配字母数字或下划线
\s 匹配任意的空白符
\d 匹配数字
\t 匹配一个制表符
\n 匹配一个换行符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W 匹配非字母数字或下划线
\D 匹配非数字
\S 匹配非空白符

[\s\S]
[\W\w]
[\d\D]
全局匹配
a|b 匹配字符a或字符b
()匹配括号内的表达式，也表示一个组。
[....]匹配字符组中的字符
[^...]匹配除了字符组中字符的所有字符

量词：

* 重复零次或者多次
+ 重复一次或者多次
？重复零次或者一次
{n},重复n次，表示具体的次数
{n,}重复n次或者更多次
{n,m}重复n到m次

量词只约束前一个字符：

*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复

.*?的用法

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x

就是取前面任意长度的字符，直到一个x出现

转义符\

在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。

在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。

2,re模块

re 模块下常用方法：

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

1 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+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。

匹配标签

import re

ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name'))  #结果 ：h1
print(ret.group())  #结果 ：<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())  #结果 ：<h1>hello</h1>

匹配整数

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']

数字匹配

1、 匹配一段文本中的每行的邮箱
      http://blog.csdn.net/make164492212/article/details/51656638

2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’；

   分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、
   一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$

3、 匹配qq号。(腾讯QQ号从10000开始)  ［1,9］[0,9]{4,}

4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$ 

6、 匹配出所有整数

爬虫练习

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

import re
import json
from urllib.request import urlopen

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')

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 = str(obj)
        f.write(data + "\n")

count = 0
for i in range(10):
    main(count)
    count += 25

简化版

flags有很多可选值：

re.I(IGNORECASE)忽略大小写，括号内是完整的写法
re.M(MULTILINE)多行模式，改变^和$的行为
re.S(DOTALL)点可以匹配任意字符，包括换行符
re.L(LOCALE)做本地化识别的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境，不推荐使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取决于unicode定义的字符属性。在python3中默认使用该flag
re.X(VERBOSE)冗长模式，该模式下pattern字符串可以是多行的，忽略空白字符，并可以添加注释

flags

计算器的作业：实现能计算类似
1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式的计算器程序

import re
#处理符号用的
def dealwith_symbol(express):
    if '--' in express:express = express.replace('--','+')
    if '+-' in express:express = express.replace('+-','-')
    if '-+' in express:express = express.replace('-+','-')
    if '++' in express:express = express.replace('++','+')
    return express
#处理乘除法
def mul_div(express):
    #a*b  a/b
    if '*' in express:
        a,b = express.split('*')
        ret = float(a)*float(b)
    elif '/' in express:
        a, b = express.split('/')
        ret = float(a) / float(b)
    return str(ret)

# 将没有括号的子表达式中的乘除法先提取出来，再计算加减法
def simplify_express(express_son):  #(9-2*5/3)
    while True:  #取乘除法计算
        ret = re.search(r'\d+\.?\d*[*/]-?\d+\.?\d*',express_son)   #(9-2*5/3)
        if ret:
            mul_div_express = ret.group()     #2*5
            result = mul_div(mul_div_express)   #
            express_son = express_son.replace(mul_div_express,result,1)   #(9-3.3)
            express_son = dealwith_symbol(express_son)
        else:break
    express_son = dealwith_symbol(express_son)
    num_lst = re.findall(r'[\+\-]?\d+\.?\d*',express_son)  #(-8)
    sum = 0
    for i in num_lst:
        sum += float(i)
    return str(sum)

# 将表达式中的括号提取出来
def remove_bracket(express):
    #\([^\(\)]+\)、\([^\(]+?\)、\([\-\d\+\/\*\.]+\)
    while True:
        ret  = re.search(r'\([^\(\)]+\)',express)
        if ret:
            express_no_bracket = ret.group()  #express_no_bracket: 没有括号的表达式
            sum = simplify_express(express_no_bracket)
            express = express.replace(express_no_bracket,sum,1)
        else:break
    return simplify_express(express)

e = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
new_express = e.replace(' ','')
result = remove_bracket(new_express)
print(result)

import re
#   1 - 2 * ( (60-30 +(-40/5) * 20) - (-4*3)/ (16-5+3*2) )  259.58823529412
def main():
    while True:
        try:
            arg = input('请输入计算的表达式:').strip()
            counter = calc(arg)
            print(counter)
            break
        except Exception:
            print('请重新输入:')
def add(arg):
    arg = arg.replace("++", "+").replace("--", "+").replace("+-", "-").replace("-+", "-")
    num = re.findall(r"([+\-]?\d+\.?\d*)", arg)#匹配所有的数字
    result = 0
    for i in num:
        result = result + float(i)
    return result

def mul(arg):
    while True:
        result = re.split(r"(\d+\.?\d*[\*/][\+-]?\d+\.?\d*)",arg,1)#匹配括号内的乘除法
        if len(result) == 3:
            bef,cen,aft = result
            if "*" in cen:
                num1,num2 = cen.split("*")
                new_cen = float(num1) * float(num2)
                arg = bef +str(new_cen) + aft
            elif "/" in cen:
                num1,num2 = cen.split("/")
                new_cen = float(num1) / float(num2)
                arg = bef + str(new_cen) + aft
        else:
            return add(arg)

def calc(arg):
    while True:
        arg = arg.replace(" ","")
        result = re.split(r"\(([^()]+)\)",arg,1)#匹配最里面的括号并且只取括号中的内容
        if len(result) == 3:
            bef,cen,aft = result
            r = mul(cen)
            arg = bef + str(r) + aft
        else:
            return mul(arg)
if __name__ == '__main__':
    main()