Python-functools （reduce，偏函数partial，lru_cache）

1、functools模块---reduce()

　　reduce方法：

　　　　reduce方法，就是减少

　　　　可迭代对象不能为空，初始值没提供就在可迭代对象总去一个元素。

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

　　　　举例1：

from functools import reduce
# reduce()
print(reduce(lambda a,x:a + x , range(4))) # 6
print(reduce(lambda a,x:a + x , range(4), 10)) # 16

num_l=[1,2,3,100]
print(reduce(lambda x,y:x+y,num_l,1)) #可以定义起始值，否则默认起始值为第一个元素
print(reduce(lambda x,y:x+y,num_l))

print(reduce(lambda a,x:a + x , []))  # 报错，根据定义看，如果没有初始值，那会去迭代对象取第一个值，但是为空，无法next(it)

2、functools ----partial 方法

　　　偏函数：把函数部分的参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并返回

　　　　　从 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

 　　　　举例 1：

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*args, *fargs, **newkeywords)
    ''' 这是什么意思？'''
    # newfunc.func = func
    # print(newfunc.func) # <function add at 0x00000000029DCF28>
    # newfunc.args = args
    # print(newfunc.args) # ()
    # newfunc.keywords = keywords
    # print(newfunc.keywords) # {'y': 5}
    return newfunc

def add(x, y):
    return x + y
newadd = partial(add,y=5)
# print(newadd(4))

　　　　举例2：

from functools import partial
import inspect

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

newadd = partial(add, 4)
print(inspect.signature(newadd))
print(newadd(5))

# (y)
# 9

newadd = partial(add, y=5)
print(inspect.signature(newadd))
print(newadd(4))

# (x, *, y=5) # 因为 y=5 是关键字传参，还是可以被更新，所以还是会出现的
# 9

newadd = partial(add, x=4,y=5)
print(inspect.signature(newadd))
print(newadd())

# (*, x=4, y=5)
# 9

newadd = partial(add,x=4,y=5)
print(inspect.signature(newadd))
print(newadd(x=10,y=12))

# (*, x=4, y=5)
# 22


# newadd = partial(add, x=5) # 报错，虽然x=5被**kwargs收了，但是 4 传入后是frags，最终赋给x，而后面有x=5,重复
# print(newadd(4))

　　　　举例3：针对 from functools import wraps 的分析

'''偏函数作用：把一些函数从多参---变成单参----这些函数就可以当无参装饰器'''

def update_wrapper(wrapper,                             
                   wrapped,                                                         
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):

def wraps(wrapped,                                            @wraps(fn) 等价 w=wraps(fn)(w) 而wraps(fn)就是一个新函数      
          assigned = WRAPPER_ASSIGNMENTS,                       wraps函数中可以看到，传入 w，其他的都是固定值，同时返回一个偏函数
          updated = WRAPPER_UPDATES):                           偏函数只有第一个参数没有定，假设生成一个新函数 new（）
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)          这个new() 只需传入 update_wrapper参数即可，当传入后，update_wrapper
                                                                只剩wrapped这个参数， w=wraps(fn)(w)这个第二个参数就是w

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

 3、lru_cache

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

• • • Least-recently-used 装饰器，lru  最近最少使用。cache缓存
    • 如果maxsize 设置为 None，则禁用LRU 功能，并且缓存可以无限制增长，当maxsize是二的幂次时，LRU 功能执行的最好
    • 如果typed设置为True，则不同类型的函数将单独缓存，例如 f(3) 和 f（3.0）将被视为具有不同结果的不同调用。

　　　　举例 1：

from functools import lru_cache
import time

@lru_cache() # 带参的装饰器
def add(x=[], y=1):
    x.append(y)
    return x

print(add())
print(add()) # 第二次执行，是直接找上次的结果，并不会在追加，如果不加缓存，就会继续追加

print(add([0])) # 不可hash，以为@lru_cache 原码影响。　

 　　　　lru_cache 源码分析：

class _HashedSeq(list):
    """ This class guarantees that hash() will be called no more than once
        per element.  This is important because the lru_cache() will hash
        the key multiple times on a cache miss.

    """

    __slots__ = 'hashvalue'

    def __init__(self, tup, hash=hash):
        self[:] = tup
        self.hashvalue = hash(tup)

    def __hash__(self):
        return self.hashvalue

def _make_key(args, kwds, typed,
             kwd_mark = (object(),),
             fasttypes = {int, str, frozenset, type(None)},
             tuple=tuple, type=type, len=len):
    """Make a cache key from optionally typed positional and keyword arguments

    The key is constructed in a way that is flat as possible rather than
    as a nested structure that would take more memory.

    If there is only a single argument and its data type is known to cache
    its hash value, then that argument is returned without a wrapper.  This
    saves space and improves lookup speed.

    """
    # All of code below relies on kwds preserving the order input by the user.
    # Formerly, we sorted() the kwds before looping.  The new way is *much*
    # faster; however, it means that f(x=1, y=2) will now be treated as a
    # distinct call from f(y=2, x=1) which will be cached separately.
    key = args
    if kwds:
        key += kwd_mark
        for item in kwds.items():
            key += item
    if typed:
        key += tuple(type(v) for v in args)
        if kwds:
            key += tuple(type(v) for v in kwds.values())
    elif len(key) == 1 and type(key[0]) in fasttypes:
        return key[0]
    return _HashedSeq(key)

def lru_cache(maxsize=128, typed=False):

# 从原码可以看出，args 只能是元组，因为最终返回  _HashedSeq(key)，而事实上，class _HashedSeq(list): 是元组继承而来，def __init__(self, tup, hash=hash):
# 而且必须可hash，所以list，set，dict都不能，
# 对传入的参数，位置参数赋值给key，之后会添加一个 object() 形成一个新的 tuple，再将关键字参数，形成的字典，以元组形式与之前的
# 的元组相加，形成新的元组，最后加一个type 即元素的类型。
# 如下：
# from functools import  _make_key
# key = _make_key((1,2,3),{'a':1},False)
# print(key) # [1, 2, 3, <object object at 0x000000000019E160>, 'a', 1]
#
# print(hash(key)) # -147545184494388729

 　　　　举例 2：

from functools import lru_cache
import time

@lru_cache()
def add(x=4, y=5):
    time.sleep(3)
    return x + y

print(1,add(4,5))
print(2,add(4))
print(3,add(y=5))
print(4,add(x=4,y=5))
print(5,add(y=5,x=4))
print(6,add(4.0,5))
# 如上，每个都要算 3 秒

@lru_cache()
def add(x=[], y=5):
    time.sleep(3)
    x.append(1)
    return x
 
print(add([1]))  #  TypeError: unhashable type: 'list'

 　　　　　总结：lru_cache装饰器应用　

• • • 使用前提：
      • 同样的函数参数一定得到同样的结果
      • 函数执行时间很长，且要多次执行
    • 本质：函数调用的参数 ==> 返回值
    • 缺点：
      • 不支持缓存过期，key无法过期，shixiao
      • 不支持清除操作
      • 不支持分布式，是一个单机缓存
    • 适用场景：单机上需要空间换时间的地方，可以用缓存来将计算编程快速查询