一.update_wrapper

该函数用于更新包装函数（wrapper），使它看起来像被包装的原函数一样。
该函数主要用于装饰器函数的定义中，置于包装函数之前。如果没有对包装函数进行更新，那么被装饰后的函数所具有的元信息就会变为包装函数的元信息，而不是原函数的元信息。

WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',  '__annotations__')
WRAPPER_UPDATES = ('__dict__',)
update_wrapper(wrapper,
               wrapped,
               assigned = WRAPPER_ASSIGNMENTS,
               updated = WRAPPER_UPDATES):

• wrapper 包装函数，被更新者
• wrapped 被包装函数，数据源
• assigned 包装函数需要替换的属性，替换的内容直接来自于被包装函数
• updated 指定包装函数需要更新的属性，更新的内容需要对照被包装函数进行更新。

该函数自动在wrapper函数添加一个wrapped属性，保留着wrapped函数

import datetime, time, functools
def logger(duration, func=lambda name, duration: print('{} took {}s'.format(name, duration))):
    def _logger(fn):
        def wrapper(*args,**kwargs):
            start = datetime.datetime.now()
            ret = fn(*args,**kwargs)
            delta = (datetime.datetime.now() - start).total_seconds() 
            if delta > duration:
                func(fn.__name__, duration) 
            return ret
        return functools.update_wrapper(wrapper, fn) 
    return _logger
@logger(5) # add = logger(5)(add) 
def add(x,y):
    time.sleep(1) 
    return x + y
print(add(5, 6), add.__name__, add.__wrapped__, add.__dict__, sep='\n')

二.functools.wraps

def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):

    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

这是一个便捷函数，定义一个wrapper函数时，作为函数装饰器调用update_wrapper()。它等价于partial(update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated),返回一个形参wrapped 有默认值的新的update_warpper 函数

import datetime, time, functools
def logger(duration, func=lambda name, duration: print('{} took {}s'.format(name, duration))):
    def _logger(fn):
        @functools.wraps(fn)
        def wrapper(*args,**kwargs):
            start = datetime.datetime.now()
            ret = fn(*args,**kwargs)
            delta = (datetime.datetime.now() - start).total_seconds() 
            if delta > duration:
                func(fn.__name__, duration) 
            return ret
        return wrapper
    return _logger
@logger(5) # add = logger(5)(add) 
def add(x,y):
    time.sleep(1) 
    return x + y
print(add(5, 6), add.__name__, add.__wrapped__, add.__dict__, sep='\n')

三.functools.reduce

reduce(function, sequence, initial=None) -> value

• function 这个函数是要有两个参数的
• sequence 序列
• initial 如果初始值没有，拿sequence第一个元素

等价于

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value

具体应用如下：

from functools import reduce
def add(x,y):
    return x + y
reduce(add,range(5))

四.functools.partial 偏函数

functools.partial(func, *args, **keywords) -> newfunc
把函数部分的参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并且返回，是对原函数的封装
partial 函数本质

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords): # 包装函数
        newkeywords = keywords.copy() newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
newfunc.func = func # 保留原函数
newfunc.args = args # 保留原函数的位置参数 
newfunc.keywords = keywords # 保留原函数的关键字参数参数 
return newfunc

五.functools.lru_cache

functools.lru_cache(maxsize=128, typed=False)

• Least-recently-used 装饰器。
• 如果maxsize 设置为None，则金庸LRU功能，并且缓存可以无限制增长，当maxsize是2的幂的时候，LRU功能执行最好
• 如果typed为True，则不同类型的函数参数将单独缓存，例如，f(3)和f(3.0)将被视为具有同结果的不同调用
• 使用前提
  1.同样的函数参数一定得到同样的结果
  2.函数执行时间很长，且要多次执行
• 本质是函数调用的参数 ->返回值
• 缺点
  1. 不支持缓存过期，key无法过期，失效
  2. 不支持清除操作
  3. 不支持分布式，是一个单机的缓存
• 使用场景，单机上需要空间换时间的地方，可以用缓存来将计算变成快速的查询

装饰器用一个有记忆的调用包装一个函数，它可以保存最近maxsize次调用。当使用同样的参数定期调用费时或I/O绑定的函数时，它可以节省时间。
因为使用字典缓存结果，所以函数的位置和关键字必须是可以哈希的。
为了帮助测量缓存的有效性并且调整maxsize 参数，可以使用cache_info() 返回一个命名元组，包含hits，misses，maxsize和currsize。在多线程环境中，hits和misses是近似值。
装饰器还提供了cache_clean() 用于清除缓存。