python装饰器

装饰器（闭包的一种运用）
1 软件的开放封闭原则（）

    1对修改是封闭的，即不允许修改源代码
    2对扩展是开放的

谁也不能保证上线后的软件，不会永远不改变了 那么假设现在有个网站已经上线了， 出来了个新需求，要求统计一下每个页面的响应时间，
或者某些页面需要记录一下日志，这些是不是要在原来的程序上添加新的功能。

这个怎么做呢

这个就要用的我们下面讲的内容：装饰器

首先
2装饰器什么
    装饰即是修饰，器即是工具（工具，目前我们所学的是不是就是函数啊）：装饰被装饰物的工具，
    举个例子：避雷针是不是一种工具，给每栋房子都装上了，房子是不是就能够避雷了
    也就是说装饰器是用来为被装饰对象添加新功能的一种工具

    装饰器本身可以是任意可调用的对象（函数）
    被装饰的对象也可以是任意可调用的对象（函数）
    那么上面我们也说了开放封闭原则
    装饰器也要遵循都原则：
        1、不能修改被装饰对象的源代码
        2、不能修改被装饰对象的调用方式

3为什么使用装饰器
    上面说了在不改变装饰对象源代码和调用方式的情况下为其添加新功能
4怎么用装饰器
    1无参数装饰器
    2有参数装饰器



1无参装饰器
首先我们来看看上面的举例子：假设现在有个网站已经上线了， 出来了个新需求，要求统计某些页面的响应时间

假设每个函数就是代表一个页面

import time
def home():
    time.sleep(2)
    print('主页')

def product():
    time.sleep(3)
    print('产品页面')

1第一种方法：

def home():
    start_time=time.time()
    time.sleep(2)
    print('主页')
    end_time = time.time()
    print('程序执行时间：%s'%(end_time-start_time))
home()

这样的话我们是实现了功能 但是改变了源代码

2第二种方法：

def home():
    time.sleep(2)
    print('主页')

start_time=time.time()
home()
end_time=time.time()
print('程序执行时间：%s'%(end_time-start_time))

这样的话是实现了不改变源代码，调用方式也没改变，但是这样行吗，我们是只为这样一个页面加这个功能吗 很多地方都要用到的功能 我们应该用函数封装起来

3那么：

def wrapper(func):
    start_time=time.time()
    func()
    end_time=time.time()
    print('程序执行时间：%s'%(end_time-start_time))

要统计主页的时间：
wrapper(home)
要统计产品页的时间：
wrapper(product)
需要把函数名称传进去

4然而传参的方式不止这种:
开始我们也说过装饰器是闭包的一种运用

def outter():
    func=home
    def wrapper():
        start_time=time.time()
        func()
        end_time=time.time()
        print('程序执行时间：%s'%(end_time-start_time))
    return wrapper

wrapper=outter()
wrapper()

5这样的话把参数写死了

def outter(func):

    def wrapper():
        start_time=time.time()
        func()
        end_time=time.time()
       print('程序执行时间：%s'%(end_time-start_time))
    return wrapper

func=outter(home) #func=wrapper
func()
#这样调用方式还是没有改变 但是我们可以看看 这里func是outter(home)执行完后的返回值赋给的变量名 我们可以修改为： 
home=outter(home) #home=wrapper 
home() 

#同理 
product=outter(product) #product=wrapper 
product()

这样的话，我们是实现了上面的功能  但是有个问题，这里暂且看来我们装饰的是一个函数  函数是不是有返回值和需要传参数啊

6这样的话 如果有返回值我们在改改：
装饰一下下面的函数：

def foo():
    print('foo')
    return 22

def outter(func):

    def wrapper():
        start_time=time.time()
        res=func()
        end_time=time.time()
        print('程序执行时间：%s'%(end_time-start_time))
        return res
    return wrapper
foo=outter(foo)
foo()

7如果函数需要传参数（最终版）

def test(x,y,k=2):
    print('test')
    return 22

def outter(func):

    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        end_time=time.time()
        print('程序执行时间：%s'%(end_time-start_time))
        return res
    return wrapper
test=outter(test)
test(1,4)

test=outter(test)

8每次都这么写太麻烦了（究极版）
但是呢 这种写法在python 是这样的

我们先定义好装饰器

def outter(func):

    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        end_time=time.time()
       print('程序执行时间：%s'%(end_time-start_time))
        return res
    return wrapper


@outter #此处就等于 home=outter(home)
def home():
    time.sleep(2)
    print('主页')

home()#这个就是被装饰后的函数

2有参数装饰器

某些页面需要记录一下日志，这些是不是要在原来的程序上添加新的功能。
有些页面的日志需要保存在文件中，有些即需要保存文件又同时需要存数据库mysql

首先我们先把装饰器写一下

def outter(func):
    def wrapper(*args,**kwargs):
        res=func()
        print('日志存文件')#区分日志存的方式

print('日志存文件和mysql') return res return wrapper @outter def home(): print('home')

我们无法需要外部传一个参数来区分日志存的方式

我们可以：

def chioceSave(type):
    def outter(func):
        def wrapper(*args, **kwargs):
            res = func()
            if(type==1):
                print('日志存文件')
            if type==2:

                print('日志存文件和mysql')
            return res

        return wrapper
    return outter

@chioceSave(type=1) #outter=chioceSave(type=1) @outter type=1  在执行了home=outter(home)
def home():
    print('home')

home()