Python装饰器详解

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
                                                    __----~~~~~~~~~~~------___
                                   .  .   ~~//====......          __--~ ~~
                   -.            \_|//     |||\  ~~~~~~::::... /~
               ___-==_       _-~o~  /    |||  \            _/~~-
        __---~~~.==~||=_    -_--~/_-~|-   |\   \        _/~
    _-~~     .=~    |  \-_    '-~7  /-   /  ||          /
  .~       .~       |   \ -_    /  /-   /   ||         /
 /  ____  /         |     \ ~-_/  /|- _/   .||        /
 |~~    ~~|--~~~~--_      ~==-/   | ~--===~~        .
          '         ~-|      /|    |-~~~       __--~~
                      |-~~-_/ |    |   ~\_   _-~            /
                           /       \__   /~                \__
                       _--~ _/ | .-~~____--~-/                  ~~==.
                      ((->/~   '.|||' -_|    ~~-/ ,              . _||
                                 -_     ~      ~~---l__i__i__i--~~_/
                                 _-~-__   ~)  --______________--~~
                               //.-~~~-~_--~- |-------~~~~~~~~
                                      //.-~~~--
                               神兽保佑
                              代码无BUG!

"""

# import heartrate
#
# heartrate.trace(browser=True)

# 01. 最简单的装饰器
'''
def decorator(func):
    def wrapper(*args, **kw):
        return func()
    return wrapper

@decorator
def function():
    print("hello, decorator")


function()
'''

# 02. 日志打印器
'''
def decorator(func):
    def wrapper(*args, **kwargs):
        print('开始准备执行：{}函数了'.format(func.__name__))

        # 真正的执行函数
        func(*args, **kwargs)

        print('{}函数执行完毕'.format(func.__name__))

    return wrapper


@decorator
def add(x, y):
    print('{} + {} = {}'.format(x, y, x + y))


add(5, 7)
'''

# 03. 时间计时器
'''
import time


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


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


want_sleep(10)
'''

# 04. 带参数的函数装饰器 (注意，是装饰器带参数，装饰器修饰的函数不带参数)
# 在原有函数装饰器的基础上外面再套一层函数
'''
def say_hello(contry):
    def wrapper(func):
        def deco(*args, **kwargs):
            if contry == "china":
                print("你好!")
            elif contry == "america":
                print('hello.')
            else:
                return

            # 真正执行函数的地方
            func(*args, **kwargs)

        return deco

    return wrapper


# 小明，中国人
@say_hello("china")
def xiaoming():
    pass


# jack，美国人
@say_hello("america")
def jack():
    pass


xiaoming()
print("------------")
jack()
'''

# 05. 高阶：不带参数的类装饰器 (装饰器修饰的函数带参数)
"""
基于类装饰器的实现，必须实现 __call__ 和 __init__两个内置函数。
__init__ ：接收被装饰函数
__call__ ：实现装饰逻辑。
"""

"""
class logger():
    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")
"""

# 06. 高阶：带参数的类装饰器 (注意:类装饰器带参数，装饰的函数也带参数)

"""
带参数和不带参数的类装饰器有很大的不同。
__init__ ：不再接收被装饰函数，而是接收传入参数。
__call__ ：接收被装饰函数，实现装饰逻辑。
"""

"""
class logger():
    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")
"""

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

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

事实上，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):
    print(a+b)
    return a + b

add(3,5)
"""

"""
>>> add    # 可见 add 变成了 Delay 的实例
<__main__.DelayFunc object at 0x107bd0be0>
>>> 
>>> add(3,5)  # 直接调用实例，进入 __call__
Wait for 2 seconds...
8
>>> 
>>> add.func # 实现实例方法
<function add at 0x107bef1e0>
"""

# 08. 装饰类的装饰器
instances = {}


def singleton(cls):
    def get_instance(*args, **kw):
        # print(cls) # <class '__main__.User'>
        cls_name = cls.__name__  # User
        print('===== 1 ====')
        # print(instances) # {}
        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


u1 = User("Tom")
"""
===== 1 ====
===== 2 ====
===== 3 ====
"""

u1.age = 20

u2 = User("Lily")
"""
===== 1 ====
"""

print(u2.age)  # 20

print(u1 == u2)  # True


# 09. wraps 装饰器
def wrapper(func):
    print(func.__name__)  # wrapped

    def inner_function():
        pass

    return inner_function


@wrapper
def wrapped():
    print('3')


print(wrapped.__name__)  # inner_function
print(wrapper(wrapped).__name__)  # inner_function
'''
上边执行func 和下边 decorator(func)  是等价的，所以上面 func.__name__ 是等价于下面decorator(func).__name__ 的
'''

# 使用 functools .wraps 装饰器，将 被修饰的函数(wrapped) 的一些属性值赋值给 修饰器函数(wrapper)
from functools import wraps


def wrapper(func):
    print(func.__name__)  # wrapped

    @wraps(func)
    def inner_function():
        pass

    return inner_function


@wrapper
def wrapped():
    pass


print(wrapped.__name__)  # wrapped

"""
准确点说，wraps 其实是一个偏函数对象（partial），源码如下

def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)
"""

"""
可以看到wraps其实就是调用了一个函数update_wrapper，改写上面的代码，在不使用 wraps的情况下，也可以让 wrapped.__name__ 打印出 wrapped
"""
from functools import update_wrapper

WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
                       '__annotations__')


def wrapper(func):
    def inner_function():
        pass

    update_wrapper(inner_function, func, assigned=WRAPPER_ASSIGNMENTS)
    return inner_function


@wrapper
def wrapped():
    pass


print('---')
print(wrapped.__name__)


# 10. 内置装饰器：property
# 通常存在于类中，可以将一个函数定义成一个属性，属性的值就是该函数return的内容,同时，会将这个函数变成另外一个装饰器
class Student(object):
    def __init__(self, name):
        self.name = name
        self.name = None

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if not isinstance(value, int):
            raise ValueError('输入不合法：年龄必须为数值!')
        if not 0 < value < 100:
            raise ValueError('输入不合法：年龄范围必须0-100')
        self._age = value

    @age.deleter
    def age(self):
        del self._age


xiaoming = Student("小明")

# 设置属性
xiaoming.age = 25

# 查询属性
print(xiaoming.age)

# 删除属性
del xiaoming.age

# 11. 其他装饰器：装饰器实战
import signal


class TimeoutException(Exception):
    def __init__(self, error='Timeout waiting for response from Cloud'):
        Exception.__init__(self, error)


def timeout_limit(timeout_time):
    def wraps(func):
        def handler(signum, frame):
            raise TimeoutException()

        def deco(*args, **kwargs):
            signal.signal(signal.SIGALRM, handler)
            signal.alarm(timeout_time)
            func(*args, **kwargs)
            signal.alarm(0)

        return deco

    return wraps