17.装饰器

1.无参装饰器

1.什么是装饰器？

装饰器是指定义一个函数，该函数用来为其他函数添加额外功能

2.为何要用装饰器？

开放封闭原则：
开放：指的是对拓展功能是开放的
封闭：指的是对修改源代码是封闭的（扩展功能的同时，对旧代码不做修改）

装饰器就是在不修改被装饰对象（函数、类等）源代码以及调用方式的前提下，为被装饰对象添加新功能

3.如何用装饰器？

需求：在不修改index函数源代码以及调用方式的前提下，为其添加统计运行时间的功能

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))

解决方案一：

失败，没有修改被装饰对象（index函数）的调用方式，但是修改了源代码

import time


def index(x, y):
    start=time.time()
    time.sleep(3)
    print('index %s %s' % (x, y))
    stop=time.time()
    print(stop-start)

index(111,222)

解决方案二：

问题：每次统计都要写一遍同样的代码，代码冗余。

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))


start = time.time()
index(111, 222)
stop = time.time()
print(stop - start)

start = time.time()
index(111, 222)
stop = time.time()
print(stop - start)

start = time.time()
index(111, 222)
stop = time.time()
print(stop - start)

解决方案三：

问题：解决了方案二的代码冗余问题，但带来了调用方式的改变问题。

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))


def wrapper():
    start = time.time()
    index(111, 222)
    stop = time.time()
    print(stop - start)


wrapper()
wrapper()
wrapper()

优化一：

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))


def wrapper(*args,**kwargs):
    start = time.time()
    index(*args,**kwargs)
    stop = time.time()
    print(stop - start)



wrapper(111,222)
wrapper(111,222)
wrapper(111,222)

优化二：

只要把需要统计运行时间的函数名当做参数，传给outter就可以了。

问题：参数上一样了，加了装饰器以后的返回值，与原函数不一样了。

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))

def outter(func):
    def wrapper(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        stop = time.time()
        print(stop - start)
    return wrapper

print(index)
#原函数 index<function index at 0x00000000004B1E18>
index=outter(index)
print(index)
#加了装饰器的index，不是一个index
# <function outter.<locals>.wrapper at 0x00000000022318C8>
index(111,22)
#这里的index已经是被装了装饰器的index了

解决方案四：装饰器的最终版本，加上功能后，参数与返回值与原函数一样。

import time


def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))
    return 666

def outter(func):
    def wrapper(*args,**kwargs):
        start = time.time()
        res=func(*args,**kwargs)
        stop = time.time()
        print(stop - start)
        return res
    return wrapper

print(index)
#原函数 index<function index at 0x00000000004B1E18>
index=outter(index)
print(index)
#加了装饰器的index，不是一个index
# <function outter.<locals>.wrapper at 0x00000000022318C8>
res=index(111,22)
#这里的index已经是被装了装饰器的index了
print(res)#666

语法糖：装饰器的方便写法

将装饰器定义在需要加装饰器的函数代码上方，如果需要加装饰器，只需在需要加装饰器的函数定义时，在函数名上一行加上@装饰器名

import time


def outter(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        stop = time.time()
        print(stop - start)
        return res

    return wrapper


@outter  # index=outter(index)
def index(x, y):
    time.sleep(3)
    print('index %s %s' % (x, y))
    return 666


index(666, 555)
# index 111 22
# 3.0
# 666

总结：无参装饰器的定义模板

def outter(func):
    def wrapper(*args, **kwargs):
        #在此处写扩展功能代码
        res = func(*args, **kwargs)
        #在此处写扩展功能代码
        return res

    return wrapper

2.有参装饰器

有碍于语法糖@的限制，装饰器函数outter只能接受一个参数：被装饰对象的内存地址（被装饰的函数名）

有参装饰器，就是在无参装饰器外面再套一层用来传参

有参装饰器模板

def 有参装饰器(参数1,参数2,……):
    def outter(func):
        def wrapper(*args, **kwargs):
            # 在此处写扩展功能代码
            res = func(*args, **kwargs)
            # 在此处写扩展功能代码
            return res

        return wrapper
    
@有参装饰器(参数1,参数2,……)
def 被装饰函数（参数）:
    pass