python第十九天

python第十九天

re模块

# findall
# search
import re
# split
# ret = re.split('\d+','alex222wusir')
# ret = re.split('\d(\d)\d','alex123wusir')
# print(ret)

# sub  替换
# ret = re.sub('\d+','H','alex123wusir456',1)
# print(ret)

# subn
# ret = re.subn('\d+','H','alex123wusir456')
# print(ret)

# match  用户输入的内容匹配的时候,要求用户输入11位手机号码,^手机号正则$
# match('手机号正则$','123eva456taibai')  规定这个字符号必须是什么样的
# search('^手机号正则$','123eva456taibai') 用来寻找这个字符串中是不是含有满足条件的子内容

# ret = re.match('\d+','123eva456taibai')
# print(ret.group())

# ret = re.search('^\d+','123eva456taibai')
# print(ret.group())

# compile -- 节省代码时间的工具
    # 假如同一个正则表达式要被使用多次
    # 节省了多次解析同一个正则表达式的时间
# ret = re.compile('\d+')
# res1 = ret.search('alex37176')
# res2 = ret.findall('alex37176')
# print(res1)
# print(res2)

# finditer -- 节省空间
# ret = re.finditer('\d+','agks1ak018093')
# for i in ret:
#     print(i.group())

# 先compile(如果没有重复使用同一个正则,也不能节省时间)
# 再finditer
# ret= re.compile('\d+')
# res = ret.finditer('agks1ak018as093')
# for r in res:
#     print(r.group())

# 列表不能用insert
# 列表不能用pop(n)

# 功能
# 性能
    # 时间 :
#         # 你要完成一个代码所需要执行的代码行数
        # 你在执行代码的过程中,底层程序是如何工作的
    # 空间
        # 是占用了宝贵的内存条资源
        # 影响程序的执行效率
# 用户体验

re模块的拾遗

# 分组命名
# import re
# ret = re.search('\d(\d)\d(\w+?)(\d)(\w)\d(\d)\d(?P<name1>\w+?)(\d)(\w)\d(\d)\d(?P<name2>\w+?)(\d)(\w)',
#           '123abc45678agsf_123abc45678agsf123abc45678agsf')
#
# print(ret.group('name1'))
# print(ret.group('name2'))

# (?P<名字>正则表达式)
# ret.group('名字')

# 分组命名的引用
# import re
# exp= '<abc>akd7008&(&*)hgdwuih</abb>008&(&*)hgdwuih</abd>'
# ret= re.search('<(?P<tag>\w+)>.*?</(?P=tag)>',exp)
# print(ret)

import re
# exp= '<abc>akd7008&(&*)hgdwuih</abc>008&(&*)hgdwuih</abd>'
# ret= re.search(r'<(\w+)>.*?</\1>',exp)
# ret= re.search('<(\w+)>.*?</\\1>',exp)
# print(ret)

import re
# ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
# print(ret)
# ret = ['1', '2', '60', '', '5', '4', '3','','']
# ret.remove('')
# print(ret)
# ret = filter(lambda n:n,ret)
# print(list(ret))

# 分组命名(?P<组名>正则) (?P=组名)
# 有的时候我们要匹配的内容是包含在不想要的内容之中的,
    # 只能先把不想要的内容匹配出来,然后再想办法从结果中去掉

爬虫例子

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)
    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

递归函数

# count = 0
# def func():
#     global count
#     count += 1
#     print(count)
#     func()
#     print(456)
# func()

# RecursionError
# 递归的最大深度1000层 : 为了节省内存空间,不要让用户无限使用内存空间
# 1.递归要尽量控制次数,如果需要很多层递归才能解决问题,不适合用递归解决
# 2.循环和递归的关系
    # 递归不是万能的
    # 递归比起循环来说更占用内存
# 修改递归的最大深度
    # import sys
    # sys.setrecursionlimit(1000000000)

# 你的递归函数 必须要停下来
# 递归函数是怎么停下来的?递归3次结束整个函数
# count = 0
# def func():        # func1
#     global count
#     count += 1     # 1
#     print(count)
#     if count == 3: return
#     func()
#     print(456)
# func()
#
# def func():        # func2
#     global count
#     count += 1     # 2
#     print(count)
#     if count == 3: return
#     func()
#     print(456)
#
#
# def func():        # func3
#     global count
#     count += 1     # 3
#     print(count)
#     if count == 3:return
#     func()
#     print(456)

# 函数的调用
# 函数的参数
# 函数的返回值

# 一个递归函数要想结束,必须在函数内写一个return,并且return的条件必须是一个可达到的条件
# 并不是函数中有return,return的结果就一定能够在调用函数的外层接收到
# def func(count):
#     count += 1
#     print(count)
#     if count == 5 : return 5
#     ret = func(count)
#     print(count ,':',ret)
#     return ret
# print('-->',func(1))

# def func(1):
#     1 += 1
#     print(2)
#     if 2 == 5 : return 5
#     ret = func(2)
#     print(ret)
#     return ret
#
# def func(2):
#     2 += 1
#     print(3)
#     if 3 == 5 : return 5
#     ret = func(3)
#     print(ret)
#     return ret
#
# def func(3):
#     3 += 1
#     print(4)
#     if 4 == 5 : return 5
#     ret = func(4)
#     print(ret)
#     return ret
#
# def func(4):
#     4 += 1
#     print(5)
#     if 5 == 5 : return 5
#     func(count)
#

# def func(count):
#     count += 1
#     print(count)
#     if count == 5 : return 5
#     return func(count)
# print('-->',func(1))

# 先写正则的题目
# 递归相关
# 1.计算阶乘 100! = 100*99*98*97*96....*1
    # 循环
    # 递归
def fin(n):
    if n ==1 :
        return n
    else:
        return n*fin(n-1)
ret = fin(7)
print(ret)

# 2.os模块:查看一个文件夹下的所有文件,这个文件夹下面还有文件夹,不能用walk
# 3.os模块:计算一个文件夹下所有文件的大小.这个文件夹下面还有文件夹,不能用walk
# 4.计算斐波那契数列
    # 找第100个数
    # 1 1 2 3 5
# 5.三级菜单 可能是n级
    # 递归 循环
    # https://www.cnblogs.com/Eva-J/articles/7205734.html#_label4
menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

带参数的装饰器

#带参数的装饰器
def xxx(*args):
    def wrapper(func):
        def inner(*args,**kwargs):
            ret = func(*args,**kwargs)
            return ret
        return inner
    return wrapper