爬虫

什么是爬虫

通过代码获取网页源码

爬取网页内嵌套的数据

import requests
ret= requests.get('https://www.baidu.com')
print(ret.content.decode('utf-8'))

正则题目

a开头由只少一个字母组成的字符串

^a[a-zA-Z]*

以1开头,中间3-5位数字,x结尾,中间的值不超过5位

1\d{3,5}x

以1开头,中间3-5位数字,x结尾,中间的值不超过5位

^1\d{3,5}x$

re模块的用法

分组命名

(?P<名字>正则表达式) 写的时候名字不加引号

ret.group("名字") 用的时候加引号

分组命名的引用

exp=<abc>sadsakdjaskl</abc>

ret=re.reach('<(?P<tag>\w+>.*?</(?P=tag)>',exp)

print(ret)

#  sadsakdjaskl


改进  使用分组的索引

ret=re.reach(r'<(?P<tag>\w+>.*?</\1>',exp)

1 普通1
\1  转义 让他 表示特殊意义  
\1在python 中 有特殊意义
解决方法1:  r'<(?P<tag>\w+>.*?</\1>'
解决方法2:  \\n  取消在python中的特殊意义 他在正则中就表示 引用第一组
    

不希望转义 直接加r

re.search(r‘?\n‘,‘?\n‘)

列表中有好多空元素

ret=["","",‘‘‘,1,2,3]

ret=filter(lambda n:n,ret)

print(list(ret))

[1, 2, 3]

分组命名

(?P<组名>正则) (?p=组名)

有时候我们要匹配的内容是包含在不想要的内容之中的

只能先把不想要的内容批出来,然后再想办法从结果中去掉

re的函数

split 分割

sub 替换

subn 替换 并显示次数 返回一个元祖 (‘字符串‘,1)

match 匹配以什么开头的 字符串

compile 节省代码时间的工具, 加入一个正则表达式 要被使用多次#,节省了多次解析一个正则表达式的时间

finditer 返回迭代器

import re
# split  分割

ret=re.split('\d+','asdasdas123asdasdasd')
print(ret)
# ['asdasdas', 'asdasdasd']

ret=re.split('\d(\d)\d','asdasdas123asdasdasd')
print(ret)

# ['asdasdas', '2', 'asdasdasd']


# sub 替换

ret=re.sub('\d+',"H",'asdsad123sadsad123132',1)
print(ret)
# asdsadHsadsad123132

ret=re.sub('\d+',"H",'asdsad123sadsad123132')
print(ret)
# asdsadHsadsadH

# subn 替换 并且告诉你 替换了几处
('asdsadHsadsadH',2)

# match  匹配以什么开头的 字符串
ret=re.match('123','123asdsad123sadsad123132')
print(ret)
# 匹配到了  <_sre.SRE_Match object; span=(0, 3), match='123'>


ret=re.match('123','asdsad123sadsad123132')
print(ret)

# 匹配不到  None

# compile   节省代码时间的工具
# 加入一个正则表达式 要被使用多次
# 节省了多次解析一个正则表达式的时间

ret=re.compile('\d+')
res1=ret.search("alex1231321")
res2=ret.findall("alex1231321")
print(res1.group())
print(res2)
# None

# finditer 返回迭代器
# finditer--节省空间

ret=re.finditer('\d+','asd45646asd456456asd13213')
for i in ret:
    print(i.group())


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

装饰器

使用函数的时候,打印日志到对应的日志文件里

复盘一下

曾经
@log
def buy_goods():
    print('买了商品')
    
#buy_goods=log(buy_goods)

现在
@logger('buy_goods')
def buy_goods():
    print('买了商品')
    
#ret=logger('buy_goods')
#buy_goods=ret('buy_goods')

流程

1. ret=logger('buy_goods')
2. logger(path)   
4.   返回  log
4.  然后 执行@log   # log('buy_goods')
5.  返回inner
6.  执行 inner(*args,**kwargs)

代码

执行函数,日志写入对应的文件

import time


def logger(path):
    def log(func):
        def inner(*args,**kwargs):
            f=func(*args,**kwargs)
            msg="%s 执行了%s" % (time.strftime('%Y-%m-%d %H:%M:%S'), func.__name__)
            with open (path,mode='a',encoding='utf-8')as f:
                f.write(msg)
            return f
        return inner
    return log

@logger('login.log')
def login():
    print("登陆的逻辑")
@logger('register.log')
def register():
    print("注册的逻辑")

@logger('good.log')      #show_goods=log(show_goods)   -->ret=log('auth.log')
def show_goods():
    print("查看所有商品")
@logger('buy.log')
def add_goods():
    print("商品加入购物车")

login()
add_goods()
show_goods()
register()

带参数的装饰器

带100个函数,分别添加一个计算函数执行时间的装饰器

有的时候需要计算时间,有的时候不需要

通过修改一个变量,能控制这100各函数的装饰器是否执行

import time
def timeee(s):

    if s=="f":
        def timee(func):
            def inner(*args, **kwargs):

                f = func(*args, **kwargs)


                return f

            return inner
        return timee

    elif s=='t':
        def timee(func):
            def inner(*args, **kwargs):
                start = time.time()
                f = func(*args, **kwargs)
                end = time.time()
                print(f"运行了{end - start}秒")
                return f

            return inner
        return timee
@timeee("t")
def a():
    time.sleep(3)
    print("a运行了")

@timeee("f")
def b():
    time.sleep(3)
    print("b运行了")


a()
b()

第二十天

原文：https://www.cnblogs.com/xueba/p/12439240.html