函数进阶之装饰器

　　一、闭包函数

　　　　1.1 定义:　　　　

　　　　何为闭：定义在函数内部的函数
　　　　何为包：定义在函数内部的函数引用外部函数的作用域的名字

1.定义在函数内部的函数
2.内部函数引用外部函数的名称空间的作用域的名字

如： def otter(x): x= 222 # 把x 放到外部函数的参数这样就不会将参数固定死 def inner()： print(x) 思路：闭包函数就是局部作用域和全局作用域的使用， 查找循序在定义阶段已经确定好，不会因为函数的调用位置的变化而变化

　　　　1.2 传参的两种方式：

　　　　 

1.直接传参：

        def inner(name):
            print(name)

2.通过闭包：内部函数数引用外部函数的变量（作用域）
　　def outter(name):  # 为了让变量是一个不固定死的函数将name 传入外部函数括号
　　　　#　name = 'coco'  # 外部非全局作用域 怎么做
　　　　  def inner():
　　　　　　　　print(name)
　　　　　#如何
　　　　　　

如图闭包函数的执行过程：：

 inner 和res  就好比一座桥梁 建立在外部调用res（）—— 让内部inner（）函数执行def inner（）的关键

应用场景：

小爬虫
    爬虫的本质就是爬取页面的html代码
    从中获取到你想要的数据(url链接地址)
    有了链接之后 你就可以顺着这个链接将所有的页面资源全部爬取下来

　　二、函数装饰器（装饰器其实也是闭包函数中的其中一种体现）

 　　　　2.1 定义：器 》》》就是一个工具

　　　　　　　装饰》》》给被装饰对象添加新的功能

　　　　2.2 为什么要用装饰器：因为现在我们在写项目的时候不可能一次性把所有的=功能都全部写完或则上线前客户需求改变，需要对函数添加新功能。那此时必须要用闭包函数，装饰器也是闭包函数的一种体现。

那我们在修改项目写装饰器之前，一定要遵循的了两个原则一个开放封闭原则。软件开发都应该遵循开放封闭原则。

开放封闭原则
对扩展是开放：>>>>何为？就是对项目的拓展功能是开放的，可以进行添加新的功能
对修改是封闭的：>>>>何为？就是对原函数的源代码和调用方式是封闭的
为什么说要对扩展是开放的呢？

因为软件开发过程不可能一次性把所有的功能都考虑完全，肯定会有不同的新功能需要不停添加。也就是说需要我们不断地去扩展已经存在代码的功能，
这是非常正常的情况。

那为什么说对修改是封闭的呢？

比如说已经上线运行的源代码，比如某个函数内部的代码是不建议直接修改的。因为函数的使用分为两个阶段：函数的定义阶段和函数的调用阶段。
因为你不确定这个函数究竟在什么地方被调用了，你如果粗暴的修改了函数内部的源代码，对整个程序造成的影响是不可控的。

总结一下就是：不修改源代码，不修改调用方式，同时还要加上新功能。

在Python中就可以使用装饰器来实现上面的需求。

注意：如果你能够保证自己的每一次修改都是准确无误、万无一失的，那你可以直接修改源代码。

什么是装饰器？
从字面上讲它也是一个工具，装饰其他对象（可调用对象）的工具。

装饰器的本质
装饰器本质上可以是任意可调用对象，被装饰的对象也可以是任意可调用对象。

　　　　结论：

　　　　2.3 装饰器（可调用对象）必须遵循的两个原则：

　　　　　　1.不可以改变被装饰对象的源代码

　　　　　　2.不可改变被装饰对象（可调用对象）调用方式

　　　　2.4 装饰器的实际应用：

　　　　　　1.无参装饰器

# 装饰器：为何用装饰器：
from functools import wraps
def outer(func):
    @wraps(func)
    def inner(username,pwd):
        # 这里可以添加在原函数执行执行的功能（）
        # 验证用户名是字符大于6
        if not (len(username) >= 6 and username.isalpha()):
            return False,'用户名输入不合法'
        res = func(username,pwd)
        # 验证密码大于6
        # 这里可以添加原函数执行之后的功能（）
        if not len(pwd)>6:
            return False,'失败'
        return res
    return inner  # 为了让外部调用巧妙设计

@outer
def login(username, pwd):

    if not (username == 'jasonn' and pwd == '1234567'):
        return False,'登录失败'
    return True, '登录成功'

rs =login('jasonn','1234567')  # 执行函数的传参必须符合我们我们自己装饰添加功能的限制条件


print(rs)  # (True, '登录成功')

 

　　从上面可以看出来装饰器的强大之处　

#

季度末，公司的领导要给大家发绩效奖金了，就提议对这段日子所有人开发的成果进行审核，审核的标准是什么呢？就是统计每个函数的执行时间。

这个时候你要怎么做呀？

你一想，这好办，灵机一动装饰器呀：既不改变原函数，也能为其加新功能+语法糖@ 简直完美：

# 统计每个函数的运行时间
import time
from functools import wraps


def outer(func):
    @wraps(func)
    def inner(*args, **kwargs):
        start_time = time.time()
        print('开始计时')
        res = func(*args, **kwargs)  # 函数加括号运行结束回到你调用的地方
        print('运行时间%s' % (time.time() - start_time))
        return res
    return inner


# 原函数
@outer  #index()= outer(index)  # 以假乱真
def index():
    # """
    # :param 这是用户名：username
    # :param  用户密码：pwd
    # :return:
    # """
    time.sleep(3)
    print('一会运行')
index()

# 开始计时
# 一会运行
# 运行时间3.000977039337158

　　

　2.有参数装饰器：用法和无参装饰器的基本一模一样，无法区别于在最外层套了一个可以进行传参。外界可以进行传参。

带参数的装饰器

假如你有成千上万个函数使用了一个装饰器，现在你想把这些装饰器都取消掉，你要怎么做？

一个一个的取消掉？ 没日没夜忙活3天。。。

过两天你领导想通了，再让你加上。。。

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)
def func():
    print(111)

func()
 

　3.wrapper()的修复技术

　　　　　　3.多层装饰器

多个装饰器装饰同一个函数

有些时候，我们也会用到多个装饰器装饰同一个函数的情况。

def outter1(func1):
    print('加载了outter1')

    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1

    return wrapper1


def outter2(func2):
    print('加载了outter2')

    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2

    return wrapper2


def outter3(func3):
    print('加载了outter3')

    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3

    return wrapper3


@outter1  # index = outter1(wapper2)
@outter2  # wrapper2 = outter2(wrapper3)
@outter3  # wrapper3 = outter3(最原始的index函数内存地址)
def index():
    print('from index')


"""
加载了outter3
加载了outter2
加载了outter1

执行了wrapper1
执行了wrapper2
执行了wrapper3
from index
"""
index()

3.装饰器的嵌套
    1.装饰的时候 从下往上执行(******)

@outter1  # index = outter1(func2)
@outter2  # func2 = outter2(func1)
@outter3  # func1 =  outter3(index)
def index():
    pass

　　三、装饰器语法糖

2.有参装饰器(最复杂就三层)
def wrappers(data):
    # data = 'file'
    def outter(func):
        def inner(*args,**kwargs):
            if data == 'file':
                # 执行被装饰函数之前你可以做的操作
                res = func(*args,**kwargs)  # * **在实参中使用
                # 执行被装饰函数之后你可以做到操作
                return res
        return inner
    return outter

 

　　四、作业

　　

一：编写函数，（函数执行的时间是随机的）
二：编写装饰器，为函数加上统计时间的功能
三：编写装饰器，为函数加上认证的功能

四：编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
注意：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式

五：编写装饰器，为多个函数加上认证功能，要求登录成功一次，在超时时间内无需重复登录，超过了超时时间，则必须重新登录

六：编写下载网页内容的函数，要求功能是：用户传入一个url，函数返回下载页面的结果

七：为题目五编写装饰器，实现缓存网页内容的功能：
具体：实现下载的页面存放于文件中，如果文件内有值（文件大小不为0），就优先从文件中读取网页内容，否则，就去下载，然后存到文件中

扩展功能：用户可以选择缓存介质/缓存引擎，针对不同的url，缓存到不同的文件中

八：还记得我们用函数对象的概念，制作一个函数字典的操作吗，来来来，我们有更高大上的做法，在文件开头声明一个空字典，然后在每个函数前加上装饰器，完成自动添加到字典的操作

九 编写日志装饰器，实现功能如：一旦函数f1执行，则将消息2017-07-21 11:12:11 f1 run写入到日志文件中，日志文件路径可以指定
注意：时间格式的获取
import time
time.strftime('%Y-%m-%d %X')

#题目一:略
#题目二:略
#题目三:略
#题目四：
db='db.txt'
login_status={'user':None,'status':False}
def auth(auth_type='file'):
    def auth2(func):
        def wrapper(*args,**kwargs):
            if login_status['user'] and login_status['status']:
                return func(*args,**kwargs)
            if auth_type == 'file':
                with open(db,encoding='utf-8') as f:
                    dic=eval(f.read())
                name=input('username: ').strip()
                password=input('password: ').strip()
                if name in dic and password == dic[name]:
                    login_status['user']=name
                    login_status['status']=True
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('username or password error')
            elif auth_type == 'sql':
                pass
            else:
                pass
        return wrapper
    return auth2

@auth()
def index():
    print('index')

@auth(auth_type='file')
def home(name):
    print('welcome %s to home' %name)


# index()
# home('egon')

#题目五
import time,random
user={'user':None,'login_time':None,'timeout':0.000003,}

def timmer(func):
    def wrapper(*args,**kwargs):
        s1=time.time()
        res=func(*args,**kwargs)
        s2=time.time()
        print('%s' %(s2-s1))
        return res
    return wrapper


def auth(func):
    def wrapper(*args,**kwargs):
        if user['user']:
            timeout=time.time()-user['login_time']
            if timeout < user['timeout']:
                return func(*args,**kwargs)
        name=input('name>>: ').strip()
        password=input('password>>: ').strip()
        if name == 'egon' and password == '123':
            user['user']=name
            user['login_time']=time.time()
            res=func(*args,**kwargs)
            return res
    return wrapper

@auth
def index():
    time.sleep(random.randrange(3))
    print('welcome to index')

@auth
def home(name):
    time.sleep(random.randrange(3))
    print('welcome %s to home ' %name)

index()
home('egon')

#题目六:略
#题目七：简单版本
import requests
import os
cache_file='cache.txt'
def make_cache(func):
    def wrapper(*args,**kwargs):
        if not os.path.exists(cache_file):
            with open(cache_file,'w'):pass

        if os.path.getsize(cache_file):
            with open(cache_file,'r',encoding='utf-8') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)
            with open(cache_file,'w',encoding='utf-8') as f:
                f.write(res)
        return res
    return wrapper

@make_cache
def get(url):
    return requests.get(url).text


# res=get('https://www.python.org')

# print(res)

#题目七:扩展版本
import requests,os,hashlib
engine_settings={
    'file':{'dirname':'./db'},
    'mysql':{
        'host':'127.0.0.1',
        'port':3306,
        'user':'root',
        'password':'123'},
    'redis':{
        'host':'127.0.0.1',
        'port':6379,
        'user':'root',
        'password':'123'},
}

def make_cache(engine='file'):
    if engine not in engine_settings:
        raise TypeError('egine not valid')
    def deco(func):
        def wrapper(url):
            if engine == 'file':
                m=hashlib.md5(url.encode('utf-8'))
                cache_filename=m.hexdigest()
                cache_filepath=r'%s/%s' %(engine_settings['file']['dirname'],cache_filename)

                if os.path.exists(cache_filepath) and os.path.getsize(cache_filepath):
                    return open(cache_filepath,encoding='utf-8').read()

                res=func(url)
                with open(cache_filepath,'w',encoding='utf-8') as f:
                    f.write(res)
                return res
            elif engine == 'mysql':
                pass
            elif engine == 'redis':
                pass
            else:
                pass

        return wrapper
    return deco

@make_cache(engine='file')
def get(url):
    return requests.get(url).text

# print(get('https://www.python.org'))
print(get('https://www.baidu.com'))


#题目八
route_dic={}

def make_route(name):
    def deco(func):
        route_dic[name]=func
    return deco
@make_route('select')
def func1():
    print('select')

@make_route('insert')
def func2():
    print('insert')

@make_route('update')
def func3():
    print('update')

@make_route('delete')
def func4():
    print('delete')

print(route_dic)


#题目九
import time
import os

def logger(logfile):
    def deco(func):
        if not os.path.exists(logfile):
            with open(logfile,'w'):pass

        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            with open(logfile,'a',encoding='utf-8') as f:
                f.write('%s %s run
' %(time.strftime('%Y-%m-%d %X'),func.__name__))
            return res
        return wrapper
    return deco

@logger(logfile='aaaaaaaaaaaaaaaaaaaaa.log')
def index():
    print('index')

index()