【python进阶】函数装饰器和类装饰器

1.闭包

        闭包就是一个函数中在嵌套一个函数，并嵌套的这个函数引用外部变量，那么这被嵌套的函数就是一个闭包。示例：

def entry(name):
    def inner():
        return f'my name is {name}'
    return inner

output = entry("李四")()
print(output)


-------------------------输出-------------------------
my name is 李四

在这个entry函数里边嵌套了一个函数inner，然后return 这个函数，那么entry("李四")的返回值就是一个可调用的对象，就可以写成：entry("李四")()，

同时被嵌套的函数也可以接受参数,  像这样调用：entry("李四")(20)

def entry(name):
    
    def inner(age):
        return f'my name is {name}, age: {age}'
    return inner

output = entry("李四")(20)
print(output)

-------------------------输出-------------------------
my name is 李四, age: 20

2.使用函数实现装饰器

python的装饰器其实也就是闭包的一种应用，它的返回值也是一个扩展了功能的函数。我先来看一下使用函数实现的装饰器。

在下面的例子中：这个“timer”就是一个装饰器，它的作用打印函数的执行消耗时间。它接受一个函数，并返回一个函数wrapper。

import time


def timer(func):
    def wrapper(*args, **kwarg):
        start = time.time()
        ret = func(*args, **kwarg)
        print(f'函数: {func.__name__}, 耗时：{time.time() - start}')
        return ret
    return wrapper


@timer
def display(name):
    time.sleep(0.5)
    print(f'my name is: {name}')



display("李四")

-------------------------输出-------------------------
my name is: 李四
函数: display, 耗时：0.5001978874206543

 如果不使用python的‘@’语法，也可以用等价的写法来使用装饰器：

display("李四") 等价于 timer(display)("李四")

3.装饰器传参

我们改造一下上边的装饰器“timer”，给它传入函数执行的次数call_times，打印函数执行call_times次总耗时间。

如果装饰器本身需要传入参数，那就需要编写一个返回decorator的函数，该函数的参数就是装饰器的参数。

import time

def timer(call_times):
    def decorator(func):
        def wrapper(*args, **kwarg):
            start = time.time()
            for i in range(call_times):
                func(*args, **kwarg)
            print(f'函数: {func.__name__} 执行{call_times}次, 总耗时：{time.time() - start}')
        return wrapper
    return decorator


@timer(4)
def run(name):
    print(f'my name is:{name}')
    time.sleep(0.5)


run("李四")

-------------------------输出-------------------------
my name is:李四
my name is:李四
my name is:李四
my name is:李四
函数: run 执行4次, 总耗时：2.0012784004211426

 带有参数的装饰器的等价写法：

timer(4) 等价于 timer(4)(run)("李四")

4.优缺点

 1）装饰器的优点：可以在不改动函数本身代码的情况下扩展函数的功能；比如给所有函数增加统一的调用信息处理

2）装饰器的缺点：函数也是对象，它有__name__等属性，但经过decorator装饰之后的函数，它们的__name__已经从原来的函数名'xxxx'变成了'wrapper'，有些依赖函数签名的代码执行就会出错；我们可以使用Python内置的functools.wraps解决这个问题，可以将wrapper.__name__修改成给xxx.__name__的值。

所以，一个完整的decorator的写法如下：

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwarg):
        start = time.time()
        ret = func(*args, **kwarg)
        print(f'函数: {func.__name__}, 耗时：{time.time() - start}')
        return ret
    return wrapper

带参数的decorator写法如下：

def timer(call_times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwarg):
            start = time.time()
            for i in range(call_times):
                func(*args, **kwarg)
            print(f'函数: {func.__name__} 执行{call_times}次, 总耗时：{time.time() - start}')
        return wrapper
    return decorator

5.使用类来实现装饰器

    装饰器不仅可以用函数实现，同样可以用类来实现一个装饰器。

import time


class Timer:
    """
    可作为装饰器的类
    """
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        start = time.time()
        ret = self.func(*args, **kwargs)
        print(f'函数: {self.func.__name__}, 耗时：{time.time() - start}')
        return ret


@Timer
def add(a, b):
    time.sleep(0.2)
    return a + b


print(add(1, 2))


-------------------输出---------------------
函数: add, 耗时：0.20009303092956543
3

使用类改写装饰器Timer，功能还是打印函数执行时间。如果觉得这个写法不好理解，可以想一下上边用的等价写法公式，在类实现的装饰器时，add的等价声明写法是：

这是一张解释图

 

 6.带参数的类装饰器

     和函数实现的装饰器一样，使用类实现的装饰器同样可以带参数。

import time

class Timer:
    """
    可作为装饰器的类
    """
    def __init__(self, call_times):
        self.call_times = call_times

    def __call__(self, func):
        self.func = func

        def wrapper(*args, **kwargs):
            start = time.time()
            for i in range(self.call_times):
                func(*args, **kwargs)
            print(f'函数:{func.__name__} 执行{self.call_times}次, 总耗时：{time.time() - start}')
        return wrapper


@Timer(4)
def add(a, b):
    time.sleep(0.2)
    return a + b


等价于 add(1, 2) = Timer(4)(add)(1, 2)
add(1, 2)


---------------------输出-----------------------
函数:add 执行4次, 总耗时：0.8017325401306152

7. 类的装饰器

 装饰器可以用函数和类实现，并且装饰器也可以用来装饰类，我们管它叫“类的装饰器”。

def to_string(cls):

    def obj_to_str(self):
        return f'{cls.__name__}:\n {str(self.__dict__)}'
    cls.__str__ = obj_to_str
    return cls


@to_string
class People:

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


# @to_string  等价于 People = to_string(People)
li = People("小李", 23, "男")
print(li)


-----------------输出-----------------------
People:
 {'name': '小李', 'age': 23, 'sex': '男'}

由函数实现的装饰器to_string,它实现的功能是将可以将类对象按照类名+类的__dict__打印对象。

这个装饰的特点是：装饰器的参数是类，返回值也是类。这样一来我们在做代码debug的时候，可以给我们定义的类加上to_string的装饰器来打印对象信息。