Python-装饰器

1、无参装饰器：

　　举例1：

def add(x, y):
    return x + y
需求后：
def add(x, y):
    print('{}.{}'.format(x, y))
    return x + y

　　　　需求：一个加法函数添加一些功能，如果向上面那样，但是上面所示是一种硬编码，也就是说，每次都会出现打印，而不是在需要的时候添加。耦合度太高！

　　***举例2：装饰器的引入：

NO 1
def add(x, y):
    return x + y

def add(x, y):
    print('{}.{}'.format(x, y))
    return x + y


NO 2 将 要修饰的内容剥离出来，被修饰的函数分开，在修饰函数里调用被修饰的函数，这样，就不会修改业务函数
def add(x, y):
    return  x + y

def sub(x, y):
    return  x - y

def logger(fn, x, y):
    print('function {}, x-{}, y-{}'.format(fn.__name__, x, y))
    ret = fn(4, 5)
    return ret

print('result = {}'.format(logger(add, 4, 5)))
print('result = {}'.format(logger(sub, 4, 5)))


function add, x-4, y-5
result = 9
function sub, x-4, y-5
result = -1





NO 3 # 可以传递各种参数

def add(x, y):
    return  x + y

def sub(x, y):
    return  x - y

def a(x, y):
    pass

def b(m, n, *args, y, x, **kwargs):
    pass


def logger(fn, *args, **kwargs): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    print('function {}, x-{}, y-{}'.format(fn.__name__, 4, 5))
    ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的
    return ret


print('result = {}'.format(logger(add, 4, 5)))
print('result = {}'.format(logger(b, 3,4,5,6,x = 7,y = 8)))


function add, x-4, y-5
result = 9
function b, x-4, y-5
result = None


NO 4 将上述 修饰函数柯里化

def add(x, y):
    return  x + y

def sub(x, y):
    return  x - y

def a(x, y):
    pass

def b(m, n, *args, y, x, **kwargs):
    pass


def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def inner(*args, **kwargs):
        print('function {}, x-{}, y-{}'.format(fn.__name__, 4, 5))
        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的
        return ret
    return inner

# print(logger(add)(4,5))

add = logger(add) #在add 覆盖之前，已经将add对应的函数赋值给fn这个辨识符

print(add(4,5)) # 此时就像调用add() 函数本身！！


NO 5 装饰器上场   @函数名

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def inner(*args, **kwargs):
        print('function {}, x-{}, y-{}'.format(fn.__name__, 4, 5))
        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的
        return ret
    return inner

@logger # add = logger(add)  ----> add = inner
def add(x, y):
    return  x + y

print(add(4, 5)) # 这的add就是inner

　　　　这种装饰器：

• • • 它是一个函数
    • 函数作为他的形参
    • 返回值也是一个函数
    • 可以使用@函数名方式，简化
      • 此处总结不准确，只是方便理解

　　　　装饰器 和 高阶函数：

　　　　　　　　装饰器是高阶函数，但装饰器是对传入的函数功能的装饰（功能增强）

　　　　举例3： 函数功能增强

#  NO 1 装饰器增强：增加一个时间计时器

import datetime

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def inner(*args, **kwargs):
        print('执行业务功能之前')
        start = datetime.datetime.now()

        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的

        delta = (start - datetime.datetime.now()).total_seconds()

        print('{}-{}'.format(fn.__name__,delta))
        print('执行业务功能之后')
        
        return ret
    return inner

@logger # add = logger(add)  ----> add = inner
def add(x, y):
    return  x + y


print(add(3,4))

2、有参装饰器：

# #有参装饰器

# no 1 文档字符串
import datetime

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''

        print('执行业务功能之前')
        start = datetime.datetime.now()

        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的

        delta = (start - datetime.datetime.now()).total_seconds()

        print('{}-{}'.format(fn.__name__,delta))
        print('执行业务功能之后')

        return ret
    return wrapper

@logger # add = logger(add)  ----> add = inner
def add(x, y):
    ''' this is add function'''
    return  x + y

print(add.__name__) #打印的是 wrapper的
print(add.__doc__)

# wrapper
#  this is wrapper function


# # no 2    输出文旦字符串  print(help(add))   当作帮助信息，让别人看懂
import datetime

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''

        print('执行业务功能之前')
        start = datetime.datetime.now()

        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的

        delta = (start - datetime.datetime.now()).total_seconds()

        print('{}-{}'.format(fn.__name__,delta))
        print('执行业务功能之后')

        return ret
    return wrapper

@logger # add = logger(add)  ----> add = inner
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)
print('-------------------')
print(help(add))   # 帮助文档，即文档字符串的信息


# wrapper
#  this is wrapper function
# -------------------
# Help on function wrapper in module __main__:
#
# wrapper(*args, **kwargs)
#     this is wrapper function
#
# None


# no 3 有参装饰器的引入 ，上面的结果，可以看出，自己一定是被装饰过了，自己的信息都变了，别人打开帮助信息并不是自己想看到的

import datetime

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理

    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的
        print('执行业务功能之后')
        return ret

    wrapper.__name__ = fn.__name__ #
    wrapper.__doc__ = fn.__doc__ #
    return wrapper

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)

# NO 4 变形2

def logger(fn): # 这里是形参定义，在这里只是对实参的中转站，不作处理
    def copy_properties(src, dest):
        dest.__name__ = src.__name__ #
        dest.__doc__ = src.__doc__ #

    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs) # 参数解构，这里才是进入相应的业务，比如进入加法，至于数据合法与否也是这里判断的
        print('执行业务功能之后')
        return ret
    copy_properties(fn, wrapper)
    # wrapper.__name__ = fn.__name__ #
    # wrapper.__doc__ = fn.__doc__ #
    return wrapper

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)

# NO 5 变现3  将修改函数放全局中，并将其柯里化

def copy_properties(src):
    def _copy(dest):
        dest.__name__ = src.__name__ #
        dest.__doc__ = src.__doc__ #
    return _copy


def logger(fn):


    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs)
        print('执行业务功能之后')
        return ret

    copy_properties(fn)( wrapper)  # 因为copy_properties() 被柯里化了
    # wrapper.__name__ = fn.__name__ #
    # wrapper.__doc__ = fn.__doc__ #
    return wrapper

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)



# NO 6 使用装饰器将其改造，相当于说，给wrapper()函数增加一个装饰器使其能够实现上面的功能
# # 也就是说修改 wrapper的文档字符串，改为业务函数的文档字符串
def copy_properties(src): # 要理解柯里化的调用方式
    def _copy(dest):
        dest.__name__ = src.__name__ # src 和dest 都是函数名
        dest.__doc__ = src.__doc__ #
        return dest
    return _copy

def logger(fn):
    #    @copy_properties   # wrapper=copy_properties(wrapper) wrapper=_copy  此时执行_copy()是缺少参数的，也就是说，这样的不对的
    @copy_properties(fn)  #  # 等价于这句话 copy_properties(fn)( wrapper) ,上面的版本的调用方式
    # wrapper=copy_properties(fn)(wrapper)  ---> wrapper = _copy --->_copy(wrapper)---->因为此时的wrapper已经变为_copy，所以还要将其变为原来的，当然是修改了字符串文档后的，所以_copy()返回dest，即wrapper
    def wrapper(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs)
        print('执行业务功能之后')
        return ret
    return wrapper

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)


# NO7 上面只是练习，事实上，是有模块的，处理字符串文档的,使用  update_wrapper(w, fn)
from functools import update_wrapper

def logger(fn):
    def w(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs)
        print('执行业务功能之后')
        return ret
    update_wrapper(w, fn) # 参数前者是修饰，后者是被修饰，它会return w，所以下面不用return w
    # return w

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)

# NO 8 类似update_wrapper的柯里化wraps 偏函数
from functools import update_wrapper,wraps

def logger(fn):
    @wraps(fn) # w=wraps(fn)(w)结构就是一个柯里化的样式
    def w(*args, **kwargs):
        ''' this is wrapper function'''
        print('执行业务功能之前')
        ret = fn(*args, **kwargs)
        print('执行业务功能之后')
        return ret
    # update_wrapper(w, fn)

    return w

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''    # 这个只能放在第一行才能打印！！！！！
    return  x + y

print(add.__name__)
print(add.__doc__)
print(add.__dict__)
print(add.__module__)
print(add.__qualname__)
print(add.__annotations__)

# add
#  this is add function
# {'__wrapped__': <function add at 0x0000000001EC3378>}
# __main__
# add
# {}

'''
WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
                       '__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    """Update a wrapper function to look like the wrapped function

       wrapper is the function to be updated
       wrapped is the original function
       assigned is a tuple naming the attributes assigned directly
       from the wrapped function to the wrapper function (defaults to
       functools.WRAPPER_ASSIGNMENTS)
       updated is a tuple naming the attributes of the wrapper that
       are updated with the corresponding attribute from the wrapped
       function (defaults to functools.WRAPPER_UPDATES)
    """
    for attr in assigned:
        try:
            value = getattr(wrapped, attr) # 拿属性 ，这里的wrapped 就是 add
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value) # 设置属性，wrapper
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    # Issue #17482: set __wrapped__ last so we don't inadvertently copy it
    # from the wrapped function when updating __dict__
    wrapper.__wrapped__ = wrapped  # 在w 函数上加了一个新的属性 fn
    # Return the wrapper so this can be used as a decorator via partial()
    return wrapper # 这个很重要，就是w = w,没有就出现大问题

def wraps(wrapped,  ---------------这是一个偏函数 # 就剩wrapper 没有给定
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    """Decorator factory to apply update_wrapper() to a wrapper function

       Returns a decorator that invokes update_wrapper() with the decorated
       function as the wrapper argument and the arguments to wraps() as the
       remaining arguments. Default arguments are as for update_wrapper().
       This is a convenience function to simplify applying partial() to
       update_wrapper().
    """
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

'''

# NO 9 增强装饰器
import datetime
import  time
from functools import update_wrapper,wraps

def logger(fn, m=5):
    @wraps(fn) # w=wraps(fn)(w)结构就是一个柯里化的样式
    def w(*args, **kwargs):
        ''' this is wrapper function'''
        start = datetime.datetime.now()
        ret = fn(*args, **kwargs)
        delta = (start - datetime.datetime.now()).total_seconds()
        if delta < m:
            print("++++++")
        else:
            print('------')
        return ret
    return w

@logger # add = logger(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''  # 这个只能放在第一行才能打印！！！！！
    time.sleep(7)
    return  x + y

print(add(3,4))

# NO 10 上面的函数，参数m 必须是缺省值，所以不灵活，所以继续修改，柯梨花
import datetime
import  time
from functools import update_wrapper,wraps

def logger(m): # 这样的话，可以随便传入更多的参数，一般最多三层,因为最终要回到_logger上
    def _logger(fn):
        @wraps(fn) # w=wraps(fn)(w)结构就是一个柯里化的样式
        def w(*args, **kwargs):
            ''' this is wrapper function'''
            start = datetime.datetime.now()
            ret = fn(*args, **kwargs)
            delta = (start - datetime.datetime.now()).total_seconds()
            if delta < m:
                print("++++++")
            else:
                print('------')
            return ret
        return w
    return _logger


@logger(3) # add = logger(3)(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''  # 这个只能放在第一行才能打印！！！！！
    time.sleep(2)
    return  x + y

print(add(4,5))

# no 11,将内部的一下功能提取出来，比如：写入日志，否则得修改原码
import datetime
import  time
from functools import update_wrapper,wraps

def logger(m,
           func=lambda name, took:print('function {} took {}s'.format(name, took))):# 加入打印到屏幕上
    def _logger(fn):
        @wraps(fn) # w=wraps(fn)(w)结构就是一个柯里化的样式
        def w(*args, **kwargs):
            ''' this is wrapper function'''
            start = datetime.datetime.now()
            ret = fn(*args, **kwargs)
            delta = (start - datetime.datetime.now()).total_seconds()
            if delta < m:
                func(fn.__name__, delta) # 将这里的功能提取出来，放到最外面，作为缺省参数
            else:
                print('------')
            return ret
        return w
    return _logger


@logger(3) # add = logger(3)(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''  # 这个只能放在第一行才能打印！！！！！
    time.sleep(2)
    return  x + y

print(add(4,5))



# no 12  如果缺省参数表示的函数不能一行搞定，也可以写最外面，然后调用
import datetime
import  time
from functools import update_wrapper,wraps

def toLog(name, took):# 加入写到日志中
    pass


def logger(m,func=toLog):# 这里写成缺省，如果要写到其他地方，可以在@looger()中添加位置参数，覆盖这个缺省参数
    def _logger(fn):
        @wraps(fn) # w=wraps(fn)(w)结构就是一个柯里化的样式
        def w(*args, **kwargs):
            ''' this is wrapper function'''
            start = datetime.datetime.now()
            ret = fn(*args, **kwargs)
            delta = (start - datetime.datetime.now()).total_seconds()
            if delta < m:
                func(fn.__name__, delta) # 将这里的功能提取出来，放到最外面，作为缺省参数
            else:
                print('------')
            return ret
        return w
    return _logger


@logger(3) # add = logger(3)(add)  ----> add = wrapper
def add(x, y):
    ''' this is add function'''  # 这个只能放在第一行才能打印！！！！！
    time.sleep(2)
    return  x + y

print(add(4,5))

 　　　　注意：

from functools import wraps

def logger(fn):
    print('------------')
    @wraps(fn)
    def wrapper(*args, **kwargs):
        print(add.__annotations__, '---')
        set = fn(*args, **kwargs)
        return  set
    print("+++++++++++++")
    return wrapper

@logger # add = logger(add) = wrapper
def add(x:int, y:int) -> int:# 返回值的注解
    return  x + y

@logger # sub = logger(sub) = wrapper
def sub(x, y):
    return x - y
'''
直接运行，可以看到是执行了的，一分析便可以看出，虽然add，sub没有调用，但是
@ 语法糖是要调用logger的，所以函数会执行。
其次，当执行add(3, 4) 时，wrapper的字符串文档会被add的覆盖，在执行sub(3, 4）
的时候，同样，wrapper的字符串文档也会被sub的覆盖，但是两者没有影响，是因为，logger
是一个全局函数，而wrapper是一个嵌套函数，也就是说是一个局部变量，所以执行add 和sub
的时候，在不同的栈里，全局函数是一个，先压栈，执行add 的时候，压wrapper，执行完后，弹出，在压
sub对应的wrapper，所以是互不影响的。
线程调用函数，线程跟栈有关，对创建对象（堆是散放的），栈是对象的引用'''
# ------------
# +++++++++++++
# ------------
# +++++++++++++