15 - reduce-pratial偏函数-lsu_cache

目录

• 介绍
• 1 reduce方法
• 2 partial方法(偏函数)
  • 2.1 partial方法基本使用
  • 2.2 partial原码分析
  • 2.3 functools.warps实现分析
• 3 lsu_cache方法
  • 3.1 基本使用
  • 3.2 lru_cache原码分析
  • 3.3 斐波那契序列的lru改造
  • 3.4 lsu_cache的总结

介绍

        functools模块存放着很多工具函数，大部分都是高阶函数，其作用于或返回其他函数的函数。一般来说，对于这个模块，任何可调用的对象都可以被视为函数。

1 reduce方法

        其含义是减少，它接受一个两个参数的函数，初始时从可迭代对象中取两个元素交给函数，下一次会将本次函数返回值和下一个元素传入函数进行计算，直到将可迭代对象减少为一个值，然后返回：reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5),

reduce(function, sequence[, initial]) -> value

• function: 两个参数的函数
• sequence：可迭代对象(不能为空)
• initital：初始值(可以理解为给函数的第一个参数指定默认值)，否则第一次会在可迭代对象中再取一个元素

下面是一个求1到100累加的栗子

# 普通版
In [24]: sum = 0
In [25]: for i in range(1,101):
    ...:     sum += i
    ...:
In [26]: print(sum)
5050

# 利用reduce版
In [22]: import functools
In [23]: functools.reduce(lambda x,y:x+y,range(101))
Out[23]: 5050

2 partial方法(偏函数)

        在前面学习函数参数的时候，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点，funtools模块中的partial方法就是将函数的部分参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并返回。从partial方法返回的函数，是对原函数的封装，是一个全新的函数。

注意：这里的偏函数和数学意义上的偏函数不一样。

partial(func, *args, **keywords) - 返回一个新的被partial函数包装过的func，并带有默认值的新函数

2.1 partial方法基本使用

In [27]: import functools
    ...: import inspect
    ...:
    ...:
    ...: def add(x, y):
    ...:     return x + y
    ...:
    ...:
    ...: new_add = functools.partial(add,1)
    ...: print(new_add)
    ...:
functools.partial(<function add at 0x000002798C757840>, 1)

In [28]:
In [28]: new_add(1,2)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-28-2d6520b7602a> in <module>
----> 1 new_add(1,2)

TypeError: add() takes 2 positional arguments but 3 were given

In [29]: new_add(1)
Out[29]: 2

• 由于我们包装了函数add，并指定了一个默认参数1，这个参数会按照位置参数，当作默认值赋给x了
• 所以当我们再次调用new_add,只需要传入y的值就行了。
• 如果再传递两个，那么连同包装前传入的1，一起传给add函数，而add函数只接受两个参数，所以会报异常。

获取一个函数的参数列表，可以使用前面学习的inspect模块

In [30]: inspect.signature(new_add)
Out[30]: <Signature (y)>

• 查看new_add的签名信息，发现，它的确只需要传入一个y就可以了。

根据前面我们所学的函数知识，我们知道函数传参的方式有很多种，利用偏函数包装后产生的新函数的传参会有所不同，下面会列举不同传参方式被偏函数包装后的签名信息。

# 最复杂的函数的形参定义方式
def add(x, y, *args, m, n, **kwargs):
    return x + y

• add1 = functools.partial(add,x=1)：包装后的签名信息(*, x=1, y, m, n, **kwargs)，只接受keyword-only的方式赋值了
• add2 = functools.partial(add,1,y=20)：包装后的签名信息(*, y=20, m, n, **kwargs)，1已经被包装给x了其他参数只接受keyword-only的方式赋值了
• add3 = functools.partial(add,1,2,3,m=10,n=20,a=30,b=40)：包装后的签名信息(*args, m=10, n=20, **kwargs),1给了x，2给了y， 3给了args，可以直接调用add3，而不用传递任何参数
• add4 = functools.partial(add,m=10,n=20,a='10')：包装后的签名信息(x, y, *args, m=10, n=20, **kwargs),a='10'已被kwargs收集，依旧可以使用位置加关键字传递实参。

2.2 partial原码分析

上面我们已经了解了partial的基本使用，下面我们来学习一下partial的原码，看它到底是怎么实现的，partial的原码存在于documentation中，下面是原码：

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()    # 偏函数包装时指定的位置位置参数进行拷贝
        newkeywords.update(fkeywords)    # 将包装完后，传递给偏函数的关键字参数更新到keyword字典中去（key相同的被替换）
        return func(*args, *fargs, **newkeywords)  # 把偏函数包装的位置参数优先传递给被包装函数，然后是偏函数的位置参数，然后是关键字参数
    newfunc.func = func    # 新增函数属性，将被包装的函数绑定在了偏函数上，可以直接通过偏函数的func属性来调用原函数
    newfunc.args = args    # 记录包装指定的位置参数
    newfunc.keywords = keywords # 记录包装指定的关键字参数
    return newfunc

上面是偏函数的原码注释，如果不是很理解，请看下图

2.3 functools.warps实现分析

现在我们在来看一下functools.warps函数的原码实现，前面我们已经说明了，它是用来拷贝函数签名信息的装饰器，它在内部是使用了偏函数实现的。

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

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

使用偏函数包装了update_wrapper函数，并设置了下面参数的默认值：

• wrapped=wrapped：将传入给wraps的函数，使用偏函数，当作update_wrapper的默认值。
• assigned=assigned：要拷贝的信息'__module__', '__name__', '__qualname__', '__doc__','__annotations__'
• updated=updated: 这里使用的是'__dict__',用来拷贝函数的属性信息

__dict__是用来存储对象属性的一个字典，其键为属性名，值为属性的值

下面来看一下update_wrapper函数，因为真正执行的就是它:

def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    for attr in assigned:
        try:
            value = getattr(wrapped, attr)
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value)
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    wrapper.__wrapped__ = wrapped   # 将被包装的函数，绑定在__wrapped__属性上。
    return wrapper

• update_wrapper在外层被wraps包装，实际上只需要传入wrapper即可
• 后面的代码可以理解为是通过反射获取wrapped的属性值，然后update到wrapper中(拷贝属性的过程)
• 最后返回包装好的函数wrapper

update_wrapper返回的就是我们的wrapper对象，所以如果不想用wraps，我们可以直接使用update_wrapper

import time
import datetime
import functools

def logger(fn):
    # @functools.wraps(fn)  # wrapper = functools.wraps(fn)(wrapper)
    def wrapper(*args, **kwargs):
        start = datetime.datetime.now()
        res = fn(*args, **kwargs)
        total_seconds = (datetime.datetime.now() - start).total_seconds()
        print('函数：{} 执行用时：{}'.format(wrapper.__name__,total_seconds))
        return res

    wrapper = functools.update_wrapper(wrapper, fn)  # 这里进行调用，但是很难看有木有？
    return wrapper

@logger
def add(x, y):
    time.sleep(2)
    return x + y

add(4,5)

这里之所以使用偏函数实现，是因为对于拷贝这个过程来说，要拷贝的属性一般是不会改变的，那么针对这些不长改变的东西进行偏函数包装，那么在使用起来会非常方便，我觉得这就是偏函数的精髓吧。

结合前面参数检查的例子，来加深functools.wraps的实现过程理解。

def check(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        sig = inspect.signature(fn)
        params = sig.parameters
        values = list(params.values())
        for i, k in enumerate(args):
            if values[i].annotation != inspect._empty:
                if not isinstance(k, values[i].annotation):
                    raise ('Key Error')
        for k, v in kwargs.items():
            if params[k].annotation != inspect._empty:
                if not isinstance(v, params[k].annotation):
                    raise ('Key Error')
        return fn(*args, **kwargs)

    return wrapper

• @functools.wraps(fn) 表示一个有参装饰器，在这里实际上等于：wrapper = functools.wraps(fn)(wrapper)
• functools.wraps(fn) 的返回值就是偏函数update_wrapper , 所以也可以理解为这里实际上：update_wrapper(wrapper)
• update_wrapper 在这里将wrapped的属性(也就是fn)，拷贝到了wrapper上，并返回了wrapper。

经过上述数说明 @functools.wraps(fn) 就等价于 wrapper = update_wrapper(wrapper)，那么再来看拷贝的过程，就很好理解了。

3 lsu_cache方法

        学习lsu_cache方法，那么不得不提cache，那什么是cache呢？我们说数据是存放在磁盘上的，CPU如果需要提取数据那么需要从磁盘上拿，磁盘速度很慢，直接拿的话，就很耗时间，所以操作系统会把一些数据提前存储到内存中，当CPU需要时，直接从内存中读取即可，但是内存毕竟是有限的，不是所有空间都用来存这些数据，所以内存中的一小部分用来存储磁盘上读写频繁的数据的空间，就可以简单的理解为cache(这里就不提CPU的L1,L2,L3 cache了).

        lsu_cache方法简单来说，就是当执行某一个函数时，把它的计算结果缓存到cache中，当下次调用时，就直接从缓存中拿就可以了，不用再次进行计算。这种特性对于那种计算非常耗时的场景时非常友好的。

把函数的计算结果缓存，需要的时候直接调用，这种模式该如何实现呢？简单来讲就是通过一个东西来获取它对应的值，是不是和字典的元素很像？通过一个key获取它对应的value！实际上大多数缓存软件都是这种key-value结构！！！

3.1 基本使用

它作为装饰器作用于需要缓存的函数，用法格式如下：

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

• maxsize:限制不同参数和结果缓存的总量，如果设置为None，则禁用LRU功能，并且缓存可以无限制增长，当maxsize是二的幂时，LRU功能执行的最好，当超过maxsize设置的总数量时，LRU会把最近最少用的缓存弹出的。
• typed:如果设置为True，则不同类型的函数参数将单独缓存，例如f(3)和f(3.0)将被视为具有不同结果的不同调用

使用被装饰的函数.cache_info()来查看缓存命中的次数，以及结果缓存的数量。

In [33]: import functools

In [34]: @functools.lru_cache()
    ...: def add(x: int, y: int) -> int:
    ...:     time.sleep(2)
    ...:     return x + y
    ...:

In [35]: import time

In [36]: add.cache_info()   # 没有执行，没有缓存，也就没有命中了
Out[36]: CacheInfo(hits=0, misses=0, maxsize=128, currsize=0)

In [37]: add(4,5)    # 执行一次，缓存中不存在，所以miss1次，本次结果将会被缓存
Out[37]: 9

In [38]: add.cache_info()   # 验证缓存信息，currsize表示当前缓存1个，misses表示错过1次
Out[38]: CacheInfo(hits=0, misses=1, maxsize=128, currsize=1)

In [39]: add(4,5)  # 本次执行速度很快，因为读取的是缓存，被命中一次，所以瞬间返回
Out[39]: 9

In [40]: add.cache_info()  # 命中加1次
Out[40]: CacheInfo(hits=1, misses=1, maxsize=128, currsize=1)

cache_info各参数含义：

• hits: 缓存命中次数。当次传入计算的参数，如果在缓存中存在，则表示命中
• misses: 未命中次数。当次传入计算的参数，如果在缓存中存在，则表示未命中
• maxsize：表示缓存的key最大数量
• currsize：已经缓存的key的数量

3.2 lru_cache原码分析

def lru_cache(maxsize=128, typed=False):
    if maxsize is not None and not isinstance(maxsize, int):
        raise TypeError('Expected maxsize to be an integer or None')

    def decorating_function(user_function):
        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
        return update_wrapper(wrapper, user_function)

    return decorating_function

        这里的返回的 decorating_function 函数中返回的 update_wrapper 是不是看起来很熟悉，没错，这里同样利用了偏函数对被包装函数的属性签名信息进行了拷贝，而传入的wrapper是才是缓存的结果，所以我们进一步查看_lru_cache_wrapper到底是怎么完成缓存的。

def _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo):
    ... ...

    cache = {}
    hits = misses = 0
    full = False

    ... ...

    def wrapper(*args, **kwds):
        # Size limited caching that tracks accesses by recency
        nonlocal root, hits, misses, full
        key = make_key(args, kwds, typed)
        with lock:

    ... ...

        这里截取部分代码进行简要说明：cache是个字典，那么就印证了之前我们的设想，的确是使用字典key-value的形式进行缓存的。字典的key是来自于make_key函数的，那么我们接下来看一看这个函数都做了哪些事

def _make_key(args, kwds, typed,
             kwd_mark = (object(),),
             fasttypes = {int, str, frozenset, type(None)},
             tuple=tuple, type=type, len=len):
    key = args
    if kwds:     # 在使用关键字传参时，遍历kwds
        key += kwd_mark  # 使用一个特殊的对象obkect() 来 作为位置传参和关键字传参的'分隔符'
        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)

• args: 是我们给函数进行的位置传参，这里是元组类型（因为不希望被修改）。
• kwargs: 关键字传参的字典。
• _HashedSeq: 可以理解为对hash()函数的封装，仅仅是计算构建好的key的hash值，并将这个值作为key进行存储的。

注意，这里的函数_make_key是以_开头的函数，目的仅仅是告诉你，不要擅自使用，但是为了学习cache的key是怎么生成的，我们可以直接调用它，来查看生成key的样子(这里只模拟参数的传递，理解过程即可)

In [41]: functools._make_key((1,2,3),{'a':1,'b':2},typed=False)  # 不限制类型
Out[41]: [1, 2, 3, <object at 0x2798734b0b0>, 'a', 1, 'b', 2]    # 缓存的key不带类型

In [49]: functools._HashedSeq(functools._make_key((1,2,3),{'a':1,'b':2},typed=True))     # 限制类型
Out[49]: [1, 2, 3, <object at 0x2798734b0b0>, 'a', 1, 'b', 2, int, int, int, int, int]  # 缓存的key带类型

key构建完毕了，_HashedSeq是如何对一个列表进行hash的呢？下面来阅读以下_HashedSeq原码

class _HashedSeq(list):
    __slots__ = 'hashvalue'

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

    def __hash__(self):
        return self.hashvalue

这里发现_HashedSeq，是一个类，当对其进行hash时，实际上调用的就是它的__hash__方法，返回的是hashvalue这个值，而这个值在__init__函数中赋值时，又来自于hash函数(这不是多此一举吗，哈哈)，tup是元组类型，这里还是对元组进行了hash，只是返回了一个list类型而已。这里为了测试，我们使用_HashedSeq对象的hashvalue属性和hash函数来对比生成的hash值

In [54]: value = functools._HashedSeq(functools._make_key((1,2,3),{'a':1,'b':2},typed=True))
In [55]: value
Out[55]: [1, 2, 3, <object at 0x2798734b0b0>, 'a', 1, 'b', 2, int, int, int, int, int]

In [56]: value.hashvalue
Out[56]: 3337684084446775700
In [57]: hash(value)
Out[57]: 3337684084446775700    # 这里两次执行的结果是相同的！

小结：

1. 通过对原码分析我们知道，lru_cache是通过构建字典来完成key到value的映射的
2. 构建字典的key来源于在_make_key函数中处理过得args，kwargs参数列表
3. 最后对列表进行hash，得到key，然后在字典中作为key对应函数的计算机结果

由于_make_key在内部是通过args和kwargs拼接来完成key的构建的，也就是说args参数位置不同或者kwargs位置不同，构建出来的key都不相同，那么对应的hash值也就不同了！！！，这一点要特别注意

In [60]: add.cache_info()
Out[60]: CacheInfo(hits=1, misses=1, maxsize=128, currsize=1)

In [61]: add(4,5)
Out[61]: 9

In [62]: add.cache_info()
Out[62]: CacheInfo(hits=2, misses=1, maxsize=128, currsize=1)

In [63]: add(4.0,5.0)
Out[63]: 9

In [64]: add.cache_info()   # 由于我们没有对类型的限制，所以int和float构建的key是相同的，这里就命中了！
Out[64]: CacheInfo(hits=3, misses=1, maxsize=128, currsize=1)

In [65]: add(5,4)
Out[65]: 9

In [66]: add.cache_info()    # 当5，4调换时，key不同，那么就要重新缓存了！
Out[66]: CacheInfo(hits=3, misses=2, maxsize=128, currsize=2)

3.3 斐波那契序列的lru改造

前面我们讲递归的时候，使用递归的方法编写fib序列，是非常优美的但是由于每次要重新计很多值，效率非常低，如果把计算过后的值进行缓存，那么会有什么不同的呢？

普通版：
import datetime

def fib(n):
    return 1 if n < 3 else fib(n - 1) + fib(n - 2)

start = datetime.datetime.now()
print(fib(40))
times = (datetime.datetime.now() - start).total_seconds()
print(times)  # 31.652353

lru_cache加成版本：
import datetime
import functools

@functools.lru_cache()
def fib(n):
    return 1 if n < 3 else fib(n - 1) + fib(n - 2)

start = datetime.datetime.now()
print(fib(40))
times = (datetime.datetime.now() - start).total_seconds()
print(times)  # 0.0

速度简直要起飞了！

3.4 lsu_cache的总结

lru_cache使用的前提是：

• 同样函数参数一定得到同样的结果
• 函数执行时间很长，且要多次执行
• 其本质就是函数调用的参数到函数返回值的映射

缺点：

• 不支持缓存过期，key无法过期、失效。
• 不支持清除操作
• 不支持分布式，是一个单机缓存

适用场景：单机上需要空间换时间的地方，可以用缓存来将计算变成快速查询。