functools模块

一.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() 用于清除缓存。

你可能感兴趣的:(functools模块)