装饰器

说装饰前我们需要先了解一下闭包函数。

闭包函数

所谓的函数闭包本质是函数的嵌套和高阶函数。
实现函数闭包要满足什么条件（缺一不可）：

1、必须嵌套函数
2、内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
3、外部函数必须返回内嵌函数——必须返回那个内部函数

闭包的作用：可以保持程序上一次运行后的状态然后继续执行。

def func():
    num=1
    def inner(a):
        nonlocal  num
        num += a
        return num
    return inner
f=func()
print(f(1))  #2
print(f(2))  #4

这就是一个闭包函数，第一次传入参数1，运行后结果为2，第二次执行是就会接着上次运行后的状态num=2继续执行，得到4。

装饰器

我们知道函数装饰器要满足如下条件：

1、不能改变原来函数的代码。
2、为函数添加新的功能。
3、不能改变函数的调用方式

优点：
　　更加优雅，代码结构更加清晰
　　将实现特定的功能代码封装成装饰器，提高代码复用率，增强代码可读性

easy模式

先从最简单的日志打印器和计时器开始

日志打印
# 这是装饰器函数，参数 func 是被装饰的函数
def logger(func):
    def wrapper(*args, **kw):
        print('主人，我准备开始执行：{} 函数了:'.format(func.__name__))

        # 真正执行的是这行。
        func(*args, **kw)

        print('主人，我执行完啦。')
    return wrapper
--------------------------------------------------
@logger
def add(x, y):
    print('{} + {} = {}'.format(x, y, x+y))

add(200,50)
--------------------------------------------------
主人，我准备开始执行：add 函数了:
200 + 50 = 250
主人，我执行完啦。


计时器
# 这是装饰函数
def timer(func):
    def wrapper(*args, **kw):
        t1=time.time()
        # 这是函数真正执行的地方
        func(*args, **kw)
        t2=time.time()

        # 计算下时长
        cost_time = t2-t1 
        print("花费时间：{}秒".format(cost_time))
    return wrapper
----------------------------------------------------------------------
import time

@timer
def want_sleep(sleep_time):
    time.sleep(sleep_time)

want_sleep(10)

花费时间：10.0073800086975098秒

进阶模式

带参数的函数装饰器

def say_hello(country):
    def wrapper(func):
        def inner(*args,**kwargs):
            if country == 'China':
                msg = '你好'
            elif country == 'USA':
                msg = 'hello'
            else:
                msg = '无法判断'
            func(*args,**kwargs)
            return msg
        return inner
    return wrapper

---------------------------------------
@say_hello('China')
def huawei():
    pass
@say_hello('USA')
def iphone():
    pass
print(huawei(),iphone())

困难模式

不带参数的类装饰器

基于类装饰器的实现，必须实现 __call__ 和 __init__两个内置函数。
__init__ ：接收被装饰函数
__call__ ：实现装饰逻辑
-------------------------------------------------------------
class logger(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("[INFO]: the function {func}() is running..."
            .format(func=self.func.__name__))
        return self.func(*args, **kwargs)

@logger
def say(something):
    print("say {}!".format(something))

say("hello")
-----------------------------输出
[INFO]: the function say() is running...
say hello!

带参数的类装饰器

上面不带参数的例子，你发现没有，只能打印INFO级别的日志，正常情况下，我们还需要打印DEBUG WARNING等级别的日志。这就需要给类装饰器传入参数，给这个函数指定级别了。
带参数和不带参数的类装饰器有很大的不同。
__init__ ：不再接收被装饰函数，而是接收传入参数。
__call__ ：接收被装饰函数，实现装饰逻辑。
# ----------------------------------------------------------
class logger(object):
    def __init__(self, level='INFO'):
        self.level = level

    def __call__(self, func): # 接受函数
        def wrapper(*args, **kwargs):
            print("[{level}]: the function {func}() is running..."
                .format(level=self.level, func=func.__name__))
            func(*args, **kwargs)
        return wrapper  #返回函数

@logger(level='WARNING')
def say(something):
    print("say {}!".format(something))

say("hello")
----------------指定WARNING级别，运行输出
[WARNING]: the function say() is running...
say hello!

使用偏函数与类实现装饰器

绝大多数装饰器都是基于函数和闭包实现的，但这并非制造装饰器的唯一方式。

事实上，Python 对某个对象是否能通过装饰器（ @decorator）形式使用只有一个要求：decorator 必须是一个“可被调用（callable）的对象。
对于这个 callable 对象，我们最熟悉的就是函数了。
除函数之外，类也可以是 callable 对象，只要实现了__call__ 函数（上面几个例子已经接触过了）。
还有容易被人忽略的偏函数其实也是 callable 对象。
接下来就来说说，如何使用 类和偏函数结合实现一个与众不同的装饰器。
如下所示，DelayFunc 是一个实现了 __call__ 的类，delay 返回一个偏函数，在这里 delay 就可以做为一个装饰器。
import time
import functools

class DelayFunc:
    def __init__(self,  duration, func):
        self.duration = duration
        self.func = func

    def __call__(self, *args, **kwargs):
        print(f'Wait for {self.duration} seconds...')
        time.sleep(self.duration)
        return self.func(*args, **kwargs)

    def eager_call(self, *args, **kwargs):
        print('Call without delay')
        return self.func(*args, **kwargs)

def delay(duration):
    """
    装饰器：推迟某个函数的执行。
    同时提供 .eager_call 方法立即执行
    """
    # 此处为了避免定义额外函数，
    # 直接使用 functools.partial 帮助构造 DelayFunc 实例
    return functools.partial(DelayFunc, duration)
# -------------------------------------------------------调用
@delay(duration=2)
def add(a, b):
    return a+b
# ----------------------------------------------------执行
>>> add    # 可见 add 变成了 Delay 的实例
<__main__.DelayFunc object at 0x107bd0be0>
>>> 
>>> add(3,5)  # 直接调用实例，进入 __call__
Wait for 2 seconds...
8
>>> 
>>> add.func # 实现实例方法
<function add at 0x107bef1e0>
08.如何写能装饰类的装饰器

用 Python 写单例模式的时候，常用的有三种写法。其中一种，是用装饰器来实现的。
instances = {}

def singleton(cls):
    def get_instance(*args, **kw):
        cls_name = cls.__name__
        print('===== 1 ====')
        if not cls_name in instances:
            print('===== 2 ====')
            instance = cls(*args, **kw)
            instances[cls_name] = instance
        return instances[cls_name]
    return get_instance

@singleton
class User:
    _instance = None

    def __init__(self, name):
        print('===== 3 ====')
        self.name = name
# 上面这个例子，装饰器就只是实现对类实例的生成的控制。

09.wraps 装饰器有啥用？

10.内置装饰器：property

11.其他装饰器：装饰器实战

源自：https://mp.weixin.qq.com/s/8z92pbhJV1ybfE6YZfvOuw