python 模块之路 re模块运用

re模块    正则混合使用                 　　　　　　        

永远不要起一个py文件的名字   这个名字和你已知的模块同名  而且没有意义   文件名字要有意义

查找:

findall : 匹配所有 每一项都是列表中的一个元素
 ret = re.findall('d+','sjkhk172按实际花费928') # 正则表达式,带匹配的字符串,flag
 ret = re.findall('d','sjkhk172按实际花费928') # 正则表达式,带匹配的字符串,flag
 print(ret)

 search : 只匹配从左到右的第一个,得到的不是直接的结果,而是一个变量,通过这个变量的group方法来获取结果
# 如果没有匹配到,会返回None,使用group会报错
 ret = re.search('d+','sjkhk172按实际花费928')
 print(ret)  # 内存地址,这是一个正则匹配的结果
 print(ret.group()) # 通过ret.group()获取真正的结果

 ret = re.search('d','owghabDJLBNdgv')
 print(ret)
 print(ret.group())

 ret = re.search('d+','sjkhk172按实际花费928')
 if ret :   # 内存地址,这是一个正则匹配的结果
     print(ret.group()) # 通过ret.group()获取真正的结果

match 从头开始匹配,相当于search中的正则表达式加上一个^
ret = re.match('d+$','172sjkhk按实际花费928')
print(ret)

# 字符串处理的扩展 : 替换 切割
# split
s = 'alex|taibai|egon|'
print(s.split('|'))
s = 'alex83taibai40egon25'
ret = re.split('d+',s)
print(ret)

# sub # 谁 旧的 新的 替换次数
ret = re.sub('d+','H','alex83taibai40egon25')
print(ret)

ret = re.sub('d+','H','alex83taibai40egon25',1)
print(ret)

# subn 返回一个元组,第二个元素是替换的次数
ret = re.subn('d+','H','alex83taibai40egon25')
print(ret)

re模块的进阶  :   时间 / 空间

compile  节省使用正则表达式解决问题的时间

编译   正则表达式   编译成字节码

在多次使用的过程中  不会多次编译

ret = re.compile('d+')   # 已经完成编译了
print(ret)
res = ret.findall('alex83taibai40egon25')
print(res)
res = ret.search('sjkhk172按实际花费928')
print(res.group())

finditer 节省你使用正则表达式解决问题的空间/内存
ret = re.finditer('d+','alex83taibai40egon25')
for i in ret:
    print(i.group())

findall   返回列表   找所有的匹配项

search  匹配就 返回一个变量,  通过group取到匹配到的第一个值, 不匹配就返回None , group会报错

match   相当于search 的正则表达式中加了一个' ^'

spilt     返回列表, 按照正则规则切割, 默认匹配的内容会被切掉

sub / subn  替换, 按照正则规则去寻找要被替换的内容,subn返回元祖, 第二个值是替换的次数

compile   编译一个正则表达式, 用这个结果去search  match  findall  finditer  能够节省时间

finditer   返回一个迭代器  所有的结果都在这个迭代器中,需要通过循坏+ group 的形式取值  能够节省内存

分组在re模块中的使用

import  re

 s = '<a>wahaha</a>'  # 标签语言 html 网页
 ret = re.search('<(w+)>(w+)</(w+)>',s)
 print(ret.group())  # 所有的结果
 print(ret.group(1)) # 数字参数代表的是取对应分组中的内容
 print(ret.group(2))
 print(ret.group(3))

# 为了findall也可以顺利取到分组中的内容,有一个特殊的语法,就是优先显示分组中的内容
 ret = re.findall('(w+)',s)
 print(ret)
 ret = re.findall('>(w+)<',s)
 print(ret)

# 取消分组优先(?:正则表达式)
 ret = re.findall('d+(.d+)?','1.234*4')
 print(ret)

# 关于分组
# 对于正则表达式来说 有些时候我们需要进行分组,来整体约束某一组字符出现的次数
 (.[w]+)?

# 对于python语言来说 分组可以帮助你更好更精准的找到你真正需要的内容
 <(w+)>(w+)</(w+)>

 split
 ret = re.split('d+','alex83taibai40egon25')
 print(ret)
 ret = re.split('(d+)','alex83taibai40egon25aa')
 print(ret)

# python 和 正则表达式 之间的特殊的约定

# 分组命名 (?P<这个组的名字>正则表达式)
 s = '<a>wahaha</a>'
 ret = re.search('>(?P<con>w+)<',s)
 print(ret.group(1))
 print(ret.group('con'))

 s = '<a>wahaha</a>'
 pattern = '<(w+)>(w+)</(w+)>'
 ret = re.search(pattern,s)
 print(ret.group(1) == ret.group(3))

# 使用前面的分组 要求使用这个名字的分组和前面同名分组中的内容匹配的必须一致
 pattern = '<(?P<tab>w+)>(w+)</(?P=tab)>'
 ret = re.search(pattern,s)
 print(ret)

 2018-12-06
 2018.12.6
 2018 12 06
 12:30:30

使用正则表达式的技巧

import  re

ret=re.findall(r"d+","1-2*(60+(-40.35/5)-(-4*3))")
# 从"1-2*(60+(-40.35/5)-(-4*3))"中取整数
 ['1', '2', '60', '40', '35', '5', '4', '3']
 print(ret)

# 你要匹配的内容太没有特点了 容易和你不想匹配的内容混在一起
# 精准的取到整数 过滤掉小数

ret=re.findall(r"d+.d+|d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret)
ret=re.findall(r"d+.d+|(d+)","1-2*(60+(-40.35/5)-(-4*3))")
ret.remove('')
print(ret)

正则表达式如果写的足够好的话  能够最大限度的简化我们的操作

正则表达式重要到什么程度

　　掌握平时作业

　　能够看懂常用的正则表达式

　　并且能够做出一些公司特异性要求的修改

简单爬虫实列

import  re

def getPage(url):   # 获取网页的字符串
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    ret = com.finditer(s)  # 从s这个网页源码中 找到所有符合com正则表达式规则的内容 并且以迭代器的形式返回
    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):  # 0  25 50  # 这个函数执行10次,每次爬取一页的内容
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)   # response_html就是这个url对应的html代码 就是 str
    ret = parsePage(response_html) # ret是一个生成器
    print(ret)
    f = open("move_info7", "a", encoding="utf8")
    for obj in ret:
        print(obj)
        data = str(obj)
        f.write(data + "
")
    f.close()

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)

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

计算器   作业  经典题目

# ret = 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )
# print(ret)　　#偷鸡做法   答案直接输出

# s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
# print(eval(s))  # 第二种偷鸡   答案直接输出

#第三种答案   模块书写

 实现能计算类似
s = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
# 等类似公式的计算器程序
ss = ''
for i in s:
     if i != ' ':
        ss += i
import re
ret = re.split('[()/]',re.search('(-?d+[/]d+)',ss).group())
for i in range(ret.count('')):ret.remove('')
fin = float(ret[0])/float(ret[1]) #(-40/5)
ret1 = re.split('[(*-+/]',re.search('[*/](d+[-]d+[*]d+[/]d+',ss).group())
for i in range(ret1.count('')):ret1.remove('')
fin1 = float(ret1[0])-float(ret1[1])*float(ret1[2])/float(ret1[3])#*(9-2*5/3
ret2 = re.split('[+*/]',re.search('[+]d+[/]d+[*]d+[/]d+[*]d+',ss).group())
for i in range(ret2.count('')):ret2.remove('')
fin2 = float(ret2[0])/float(ret2[1])*float(ret2[2])/float(ret2[3])*float(ret2[4]) #+7/3*99/4*2998
ret3 = re.split('[+*/)]',re.search('[+]d+[*]d+[/]d+)',ss).group())
for i in range(ret3.count('')):ret3.remove('')
fin3 = float(ret3[0])*float(ret3[1])/float(ret3[2]) #+10*568/14)
ret4 = re.split('[(-]',re.search('(d+[-](?[-]?d+)?',ss).group())
for i in range(ret4.count('')):ret4.remove('')
fin4 = float(ret4[0])-float(ret4[1]) #(60-30
ret5 = re.split('[()*]',re.search('([-]?d+[*](?[-]?d+)?)',ss).group())
for i in range(ret5.count('')):ret5.remove('')
fin5 = float(ret5[0])*float(ret5[1]) #(-4*3)
ret6 = re.split('[/()-*]',re.search('[/]((?[-]?d+[-](?[-]?d+)?[*](?[-]?d+)?))',ss).group())
for i in range(ret6.count('')):ret6.remove('')
fin6 = float(ret6[0])-float(ret6[1])*float(ret6[2]) #/(16-3*2))
ret7 = re.match('(?[-]?d+)?',ss).group()
fin7 = float(ret7) #1
ret8 = re.split('[-*(]',re.search('(?[-]?d+)?[*]((',ss).group())
for i in range(ret8.count('')):ret8.remove('')
fin8 = float(ret8[0])
fin9 = fin7-fin8*(fin4+fin*(fin1+fin2+fin3))-fin5/fin6
print(fin9)
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))'))

思路如下:

s = '1 - 2 * 12'
# 正则表达式 函数 循环

# 匹配内层不再有括号的子表达式
# 计算
    # 先计算乘除法
    # 再计算加减法
# 一个括号计算完毕
# 将结果和括号进行替换
# 如何处理符号

# 1.先把所有的空格去掉
    # 匹配 内层不再有括号的子表达式
    # 匹配乘除法
    # 匹配加减法
# 2.远离递归,如果要用递归,请考虑返回值的问题

拼搏  努力