17functools

不念不忘少年蓝@ 2022-01-10 22:57 182阅读 0赞

functools

注：

from collections import namedtuple

from collections import defaultdict

from collections import OrderedDict

pycharm中ctrl+选中方法，可查看源码；

functools模块：

from functools import update\_wrapper

from functools import wraps   \#装饰器，用于复制被包装函数属性@wraps(fn)

from functools import partial

from functools import lru\_cache

from functools import total\_ordering

# partial方法： #

偏函数，把函数部分的参数固定下来（闭包，把源函数及参数保存下来），相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并返回；

从partial生成的新函数，是对源函数的封装；

很有用，在使用函数封装等技巧时用到，functools.wraps里就用到了partial；

例：

In \[1\]: import functools

In \[2\]: def add(x,y)->int:

...:     return x+y

...:

In \[3\]: newadd=functools.partial(add)

In \[4\]: newadd(4,5)

Out\[4\]: 9

In \[5\]: newadd=functools.partial(add,y=4)

In \[6\]: newadd(4)

Out\[6\]: 8

In \[7\]: newadd=functools.partial(add,x=4)

In \[8\]: newadd(y=5)

Out\[8\]: 9

In \[9\]: newadd=functools.partial(add,6)

In \[10\]: newadd(5)   \#相当于functools.partial(add,6)(5)，一般不这么写，分开写

Out\[10\]: 11

In \[11\]: import inspect

In \[12\]: inspect.signature(add)

Out\[12\]: <Signature (x, y) -> int>

In \[13\]: inspect.signature(newadd)

Out\[13\]: <Signature (y) -> int>

例：

In \[14\]: def add(x,y,\*args)->int:

...:     print(args,'\\t\\t',x+y)

...:     return x+y

...:

In \[15\]: newadd=functools.partial(add,4,5,6,7)

In \[16\]: newadd(8)

(6, 7, 8)             9

Out\[16\]: 9

In \[17\]: newadd(8,9)

(6, 7, 8, 9)                  9

Out\[17\]: 9

In \[18\]: newadd(8,9,y=20,x=26)   \#新函数中没有关键字参数

\---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-18-618583db3e76> in <module>()

\----> 1 newadd(8,9,y=20,x=26)

TypeError: add() got multiple values for argument 'x'

In \[19\]: newadd()

(6, 7)                  9

Out\[19\]: 9

In \[20\]: inspect.signature(add)

Out\[20\]: <Signature (x, y, \*args) -> int>

In \[21\]: inspect.signature(newadd)

Out\[21\]: <Signature (\*args) -> int>

# functools.lru\_cache #

import functools

functools.lru\_cache(maxsize=128,typed=False)，带参装饰器，使用时必须加()，一般不加typed=True，maxsize=None；

lru，least-recently-used，最近最少使用；

如果maxsize设为None，则禁用lru功能，且缓存可无限制增长；当maxsize是2的幂时，lru功能执行的最好；

如果typed设为True，则不同类型的函数参数将单独缓存，如f(3)和f(3.0)将被视为具有不同结果的不同调用；

缓存机制是什么？dict数据类型；

lru\_cache装饰器应用：

使用前提：同样的函数参数一定得到同样的结果；函数执行时间很长，且要多次执行；

本质，函数调用的参数=>返回值；

缺点，不支持缓存过期，key无法过期、失效；不支持清除操作；不支持分布式，是一个单机的缓存（单机内共用；单机内进程用；单机内线程用）；

适用场景，单机上需要空间换时间的地方，可用缓存来使计算变为快速的查询；

注：

好的算法借用缓存，是锦上添花；

如果算法不优秀，借用缓存相当于是空间换时间；时间换空间（压缩）；

buffer，缓冲，FIFO先进先出队列；

例：

import functools

import time

@functools.lru\_cache()   \#带参装饰器必须加()

def add(x,y=5):

time.sleep(3)

ret = x + y

print(ret)

return ret

In \[24\]: add(4)

Out\[24\]: 9

In \[25\]: add(4)   \#快

Out\[25\]: 9

In \[26\]: add(4,5)

Out\[26\]: 9

In \[27\]: add(4,5)   \#快

Out\[27\]: 9

In \[28\]: add(4,y=5)

Out\[28\]: 9

In \[29\]: add(4,y=5)   \#快

Out\[29\]: 9

In \[30\]: add(x=4,y=5)

Out\[30\]: 9

In \[31\]: add(y=5,x=4)   \#关键字参数相同，对收集的关键字参数进行排序（将字典内的kv对转为二元组）

Out\[31\]: 9

In \[32\]: add(4.0,5)   \#快，typed=False

Out\[32\]: 9

例：

import functools

@functools.lru\_cache()

def fib(n):

if n < 2:

return n

return fib(n-1) + fib(n-2)

print(\[fib(x) for x in range(35)\])

习题：

1、实现一个cache装饰器，实现过期，可自动清除，可以不换出；

2、写一个命令分发器：

程序员可方便的注册函数到某一个命令，用户输入命令时，路由到注册的函数；

如果此命令没有对应的注册函数，执行默认函数；

用户输入用input('>> ')；

1、

简化设计，函数的形参定义不包含可变位置参数、可变关键字参数和keyword-only参数，可不考虑缓存满了之后的换出问题；

数据类型的选择：

缓存的应用场景，是有数据需要频繁查询，且每次查询都需要大量计算或等待时间之后才能返回结果的情况，使用缓存来提高查询速度，用空间换取时间；

cache选用什么数据结构？

便于查询的，且能快速找到数据的数据结构；

每次查询的时候，只要输入一致，就该得到同样的结果，顺序一致，如减法函数，参数顺序不一致，结果不一样；

基于以上分析，此数据结构是dict，通过一个key对应一个value；

key是参数列表组成的结构，value是函数的返回值，难点在于key如何处理；

key的存储？

key必须是hash类；

key能接受到位置参数和关键字参数传参；

位置参数是被收集在一个tuple中的，本身就有顺序；

关键字参数被收集在一个字典中，本身无序，这会带来一个问题，传参的顺序未必是字典中保存的数据，如何解决？1、OrderedDict；2、不用OrderedDict，用一个tuple保存排过序的dict的item的kv对；

key的异同？

什么才算是相同的key：

lru\_cache实现了，add(y=5,x=4)和add(x=4,y=5)相同，而add(4,5)、add(4,y=5)、add(x=4,y=5)均不同，可看出单独处理了位置参数和关键字参数；但是函数定义中有默认值def add(4,y=5)，如何理解add(4)和add(4,5)是否一样？若认为一样，lru\_cache无能为力，需要使用inspect来自己实现算法；

key的要求？

必须是hashable；

由于key是所有实参组合而成，而且最好要作为key的，key一定要可hashable，但如果key有不可hashable类型数据，就无法完成，如def add(x=\[\],y=5)这种情况不考虑；

缓存必须使用key，但key必须可hashable，所以只能使用实参是不可变类型的函数调用；

key算法设计：

inspect模块获取函数签名后，取parameters，这是一个有序字典，会保存所有参数的信息；

构建一个字典params\_dict，按位置顺序从args中依次对应参数名和传入的实参，组成kv对，存入params\_dict中，kwargs所有值update到params\_dict中；

如果使用了缺省值的参数，不会出现在实参params\_dict中，会出现在签名的parameters中；

调用的方式：

普通函数调用可以，但过于明显；

最好类似lru\_cache这种方式，让调用者无察觉的使用缓存，构建装饰器函数；

过期什么？

某一个key过期，可以对每一个key单独设置过期时间，也可以对这些key统一设定过期时间，此例统一设定过期时间，当key生存超过了这个时间，就自动被清除；

此例未考虑多线程问题，这种过期机制，每一次都有遍历所有数据，大量数据时，遍历会有效率问题；

清除的时机？

用到某个key之前，先判断是否过期，如果过期重新调用函数生成新的key对应value值；

一个线程负责清除过期的key（之后实现），本例在创建key之前，清除所有过期的key；

value的设计？

key=>(v,createtimestamp)，适合key过期的时间都是统一设定，配合用这种；

key=>(v,createtimestamp,duration)，每一个key就可单独控制过期时间，这种设计，\-1可表示永不过期，正整数表示持续一段时间过期；

例：

from functools import wraps

import inspect

import time

def m\_cache(fn):

local\_cache = \{\}

@wraps(fn)

def wrapper(\*args ,\*\*kwargs):

\#print(args,kwargs)

key\_dict = \{\}

sig = inspect.signature(fn)

params = sig.parameters

param\_list = list(params.keys())   \#位置参数

for i,v in enumerate(args):

k = param\_list\[i\]

key\_dict\[k\] = v

\#         for k,v in kwargs.items():

\#             key\_dict\[k\] = v

key\_dict.update(kwargs)   \#关键字参数

key = tuple(sorted(key\_dict.items()))

if key not in local\_cache.keys():

ret = fn(\*args,\*\*kwargs)

local\_cache\[key\] = ret

return local\_cache\[key\]

return wrapper

@m\_cache

def add(x,y=5):

time.sleep(3)

ret = x + y

return ret

注：

解决了

add(4,5)

add(4,y=5)

add(x=4,y=5)

add(y=5,x=4)

例：

from functools import wraps

import inspect

import time

def m\_cache(fn):

local\_cache = \{\}

@wraps(fn)

def wrapper(\*args ,\*\*kwargs):

\#        print(args,kwargs)

key\_dict = \{\}

sig = inspect.signature(fn)

params = sig.parameters

param\_list = list(params.keys())

for i,v in enumerate(args):

k = param\_list\[i\]

key\_dict\[k\] = v

\#         for k,v in kwargs.items():

\#             key\_dict\[k\] = v

key\_dict.update(kwargs)

for k in params.keys():   \#默认值参数

if k not in key\_dict.keys():

key\_dict\[k\] = params\[k\].default

key = tuple(sorted(key\_dict.items()))

if key not in local\_cache.keys():

ret = fn(\*args,\*\*kwargs)

local\_cache\[key\] = ret

return local\_cache\[key\]

return wrapper

@m\_cache

def add(x,y=5):

time.sleep(3)

ret = x + y

return ret

注：

解决了

add(4)

例：

from functools import wraps

import inspect

import time

import datetime

def m\_cache(duration):

def \_cache(fn):

local\_cache = \{\}

@wraps(fn)

def wrapper(\*args ,\*\*kwargs):

\#         print(args,kwargs)

expire\_keys = \[\]   \#此处要将函数抽到一个函数里，用单独线程来运行

for k,(\_,ts) in local\_cache.items():

if datetime.datetime.now().timestamp() - ts > duration:

expire\_keys.append(k)

for k in expire\_keys:

local\_cache.pop(k)

key\_dict = \{\}

sig = inspect.signature(fn)

params = sig.parameters

param\_list = list(params.keys())

for i,v in enumerate(args):

k = param\_list\[i\]

key\_dict\[k\] = v

\#         for k,v in kwargs.items():

\#             key\_dict\[k\] = v

key\_dict.update(kwargs)

for k in params.keys():

if k not in key\_dict.keys():

key\_dict\[k\] = params\[k\].default

key = tuple(sorted(key\_dict.items()))

if key not in local\_cache.keys():

ret = fn(\*args,\*\*kwargs)

\#             local\_cache\[key\] = ret

local\_cache\[key\] = (ret,datetime.datetime.now().timestamp())

return local\_cache\[key\]

return wrapper

return \_cache

def logger(fn):

@wraps(fn)

def wrapper(\*args,\*\*kwargs):

start = datetime.datetime.now()

ret = fn(\*args,\*\*kwargs)

delta = (datetime.datetime.now() - start).total\_seconds()

print(delta)

return ret

return wrapper

@m\_cache(5)   \#两装饰器不分先后

@logger

def add(x,y=5):

time.sleep(3)

ret = x + y

return ret

注：

解决了缓存过期；

例：

from functools import wraps

import inspect

import time

import datetime

def m\_cache(duration):

def \_cache(fn):

local\_cache = \{\}

@wraps(fn)

def wrapper(\*args ,\*\*kwargs):

\#         print(args,kwargs)

def clear\_expire(cache):

expire\_keys = \[\]

for k,(\_,ts) in local\_cache.items():

if datetime.datetime.now().timestamp() - ts > duration:

expire\_keys.append(k)

for k in expire\_keys:

local\_cache.pop(k)

clear\_expire(local\_cache)

def make\_key():

key\_dict = \{\}

sig = inspect.signature(fn)

params = sig.parameters

param\_list = list(params.keys())

for i,v in enumerate(args):

k = param\_list\[i\]

key\_dict\[k\] = v

\#         for k,v in kwargs.items():

\#             key\_dict\[k\] = v

key\_dict.update(kwargs)

for k in params.keys():

if k not in key\_dict.keys():

key\_dict\[k\] = params\[k\].default

return tuple(sorted(key\_dict.items()))

key = make\_key()

if key not in local\_cache.keys():

ret = fn(\*args,\*\*kwargs)

\#             local\_cache\[key\] = ret

local\_cache\[key\] = (ret,datetime.datetime.now().timestamp())

return local\_cache\[key\]

return wrapper

return \_cache

def logger(fn):

@wraps(fn)

def wrapper(\*args,\*\*kwargs):

start = datetime.datetime.now()

ret = fn(\*args,\*\*kwargs)

delta = (datetime.datetime.now() - start).total\_seconds()

print(delta)

return ret

return wrapper

@m\_cache(5)

@logger

def add(x,y=5):

time.sleep(3)

ret = x + y

return ret

注：

将各功能模块化（抽取为函数）；

2、

例：

commands = \{\}

def reg(name,fn):

commands\[name\] = fn

def default\_func():

print('unknown command')

def dispatcher():

while True:

cmd = input('>> ')

if cmd.strip() == 'quit':

return

commands.get(cmd,default\_func)()

def foo1():

print('welcome magedu')

def foo2():

print('welcome python')

reg('mag',foo1)

reg('py',foo2)

dispatcher()

例：

commands = \{\}

def reg(name):

def \_reg(fn):

commands\[name\] = fn

return fn

return \_reg

def default\_func():

print('unknown command')

def dispatcher():

while True:

cmd = input('>> ')

if cmd.strip() == 'quit':

return

commands.get(cmd,default\_func)()

@reg('mag')

def foo1():

print('welcome magedu')

@reg('py')

def foo2():

print('welcome python')

\# reg('mag',foo1)

\# reg('py',foo2)

dispatcher()

注：

封装；

例：

def cmds\_dispatcher():

commands = \{\}

def reg(name):

def \_reg(fn):

commands\[name\] = fn

return fn

return \_reg

def default\_func():

print('unknown command')

def dispatcher():

while True:

cmd = input('>> ')

if cmd.strip() == 'quit':

return

commands.get(cmd,default\_func)()

return reg,dispatcher

reg,dispatcher = cmds\_dispatcher()

@reg('mag')

def foo1():

print('welcome magedu')

@reg('py')

def foo2():

print('welcome python')

\# reg('mag',foo1)

\# reg('py',foo2)

dispatcher()

注：

再次封装；

# functools.total\_ordering #

\_\_lt\_\_、\_\_le\_\_、\_\_eq\_\_、\_\_gt\_\_、\_\_ge\_\_，是比较大小必须实现的方法，但全部写完太麻烦，使用此装饰器可大大简化代码；

查看源码，该函数实现复杂，效率不高；

此装饰器要求，类中必须实现\_\_eq\_\_()，另在其它比较方法中选一个即可；

如，定义了\_\_eq\_\_()和\_\_lt\_\_()，在用其它方法时，该装饰器才推演（大量计算），在用到==和<时则直接使用，不进行推演；

在比较时，若不用此装饰器，则要把所有的比较方法写全，如写不全则报错TypeError: '<' not supported between instances of 'A' and 'A'，例如只写了\_\_ge\_\_()方法，在使用>=和<=时没问题，但当使用<或>时报错；

functools.total\_ordering应用场景：

偶尔比较时；

若经常比较，要把比较方法全部写到类里，这样效率高；

例：

from functools import total\_ordering

@total\_ordering

class A:

def \_\_init\_\_(self,x):

self.x = x

\# def \_\_ge\_\_(self, other):

\#     return self.x >= other.x

def \_\_eq\_\_(self, other):

return self.x == other.x

def \_\_lt\_\_(self, other):

return self.x <= other.x

a = A(5)

b = A(6)

print(a >= b)

print(a <= b)

print(a < b)

print(a > b)

输出：

False

True

False

转载于:https://blog.51cto.com/jowin/2388636

17functools

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 functools.wrap的使用

相关 python functools wrap_python 牛逼的functools.py

相关 PYTHON-FUNCTOOLS模块

相关 python functools模块

相关 python functools模块

相关偏函数functools.partial

相关偏函数functools.partial

相关 python functools 模块

相关 python functools

相关 17functools