Python 内包和装饰器
内包和装饰器
Python和JavaScript(暂时只研究过JS内包😆所以拿来举例)一样都支持内包，而内包又是装饰器的基础，所以本篇文章就简单总结一下本人关于内包和装饰器的理解和使用。
1.内包
在统计或者金融领域，可能需要一个函数实现，输入一个数据，来更新当前的平均值，例如下面的avg(此例来自fluent python)：
>>> avg(10)
10.0
>>> avg(11)
10.5
>>> avg(12)
11.0
如果没有内包，我们可能会定义一个如下class来完成该需求：
class Avg():
def __init__(self):
self.num_list = list()
def __call__(self, num):
self.num_list.append(num)
total = sum(self.num_list)
return total/len(self.num_list)
测试效果如下：
>>> from avg import Avg
>>> avg1 = Avg()
>>> avg1(1)
1.0
>>> avg1(9)
5.0
而使用内包之后，我们可以通过如下代码完成该功能：
def average():
num_list = list()
def cal_avg(num):
num_list.append(num)
total = sum(num_list)
return total/len(num_list)
return cal_avg
测试效果：
>>> from avg import average
>>> avg1 = average()
>>> avg1 = average()
>>> avg1(1)
1.0
>>> avg1(2)
1.5
从上面这个例子我们可以看到， 内包实际上是利用python中一切皆对象(包括函数)的特性， 通过average返回了cal_avg函数对象，而cal_avg函数对象还包括其函数域的局部变量信息。那么有疑问了，num_list并不在cal_avg的函数域(少年你骗我吧😢)， 那是因为num_list是cal_avg的自由变量(free variable),指不在本定义域中绑定的变量，可以查看__code__来查看编译后的变量类型：
>>> avg1.__code__.co_varnames
('num', 'total')
>>> avg1.__code__.co_f
avg1.__code__.co_filename avg1.__code__.co_firstlineno avg1.__code__.co_flags avg1.__code__.co_freevars
>>> avg1.__code__.co_freevars
('num_list',)
而num_list的结果都保存在__closure__:
>>> avg1.__closure__[0]
<cell at 0x10e81f3d8: list object at 0x10ea53cc8>
>>> avg1.__closure__[0].cell_contents
[1, 2]
下面贴出avg1的字节代码：
>>> from dis import dis
>>> dis(avg1)
12 0 LOAD_DEREF 0 (num_list)
2 LOAD_ATTR 0 (append)
4 LOAD_FAST 0 (num)
6 CALL_FUNCTION 1
8 POP_TOP
13 10 LOAD_GLOBAL 1 (sum)
12 LOAD_DEREF 0 (num_list)
14 CALL_FUNCTION 1
16 STORE_FAST 1 (total)
14 18 LOAD_FAST 1 (total)
20 LOAD_GLOBAL 2 (len)
22 LOAD_DEREF 0 (num_list)
24 CALL_FUNCTION 1
26 BINARY_TRUE_DIVIDE
28 RETURN_VALUE
从反汇编结果可以看出，avg1首先执行对num_list的解引用，然后执行append吧啦吧啦，我觉得自己表达能力有限(其实是懒)，不过代码比较简单，也容易理解吧。
nonlocal
OK，本来我觉得这个求平均值的函数效率太低，想稍微修改一下:
def adv_avg():
cnt = 0
avg = 0
def cal_avg(num):
cnt = cnt + 1
avg = avg + (num - avg)/cnt
return avg
return cal_avg
执行一下咯，尼玛又是一个坑啊：
>>> from avg import adv_avg
>>> avg = adv_avg()
>>> avg(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Users/xiowang/Documents/Py/decorator/avg.py", line 21, in cal_avg
cnt = cnt + 1
UnboundLocalError: local variable 'cnt' referenced before assignment
为什么会这样呢？原因就是数字，字符串，元组这些不可变类型执行cnt = cnt + 1时，会创建一个新的cnt，而不是去引用。因此这时就需要用到nonlocal来显示声明变量是外部定义的：
def adv_avg():
cnt = 0
avg = 0
def cal_avg(num):
nonlocal cnt, avg
cnt = cnt + 1
avg = avg + (num - avg)/cnt
return avg
return cal_avg
OK, 修改之后，再运行，perfect:
>>> from avg import adv_avg
>>> avg3 = adv_avg()
>>> avg3(1)
1.0
>>> avg3(2)
1.5
>>> avg3(3)
2.0
2.装饰器
对于装饰器本人理解并不深，但是从名字理解，装饰器就是给用来点缀函数或者类（都是对象）。我打个比方，古代同样两幅画，经过皇家印章盖个印，那么他添加了皇室属性，那收藏价值必须飙升呀，怎么都值个4，5线城市的小房子啊（咋最近老喜欢说房子，还不敢说上海的房子，泪啊😢），其实装饰器就是干盖章这回事呀，完成比如给函数添加打log，计时等功能。
一个关于装饰很经典的例子，给函数添加计时功能：
from time import time, sleep
def decoTime(func):
def retFunc():
start = time()
func()
now = time()
print("spend time:{:.2f}".format(now-start))
print("func_name: {}".format(func.__name__))
return retFunc
@decoTime
def myfunc():
sleep(2)
myfunc()
print("myfunc name:{}".format(myfunc.__name__))
执行结果如下：
spend time:2.00
func_name: myfunc
myfunc name:retFunc
这里我们通过上面提到的内包完成一个简单的装饰器，这里执行：
@decoTime
def myfunc():
等价于：
decoTime(myfunc)
所以会执行retFunc函数的内容。
functools.wraps
另外值得注意的是，这里因为我们返回了一个retFunct函数对象，因此myfunc的__name__属性也被修改为了retFunc。可是我们想保留__name__属性，那么就可以使用functools.wraps():
from time import time, sleep
from functools import wraps
def decoTime(func):
@wraps(func)
def retFunc():
start = time()
func()
now = time()
print("spend time:{:.2f}".format(now-start))
print("func_name: {}".format(func.__name__))
return retFunc
@decoTime
def myfunc():
sleep(2)
myfunc()
print("myfunc name:{}".format(myfunc.__name__))
使用wraps之后的执行结果：
spend time:2.00
func_name: myfunc
myfunc name:myfunc
带参数的装饰器
装饰器也是能带参数滴：
from time import time, sleep
from functools import wraps
def decoTime(flag):
if flag=="normal":
def _decoTime(func):
@wraps(func)
def retFunc(*args, **kw):
start = time()
func(*args, **kw)
now = time()
print("spend time:{:.2f}".format(now-start))
print("func_name: {}".format(func.__name__))
return retFunc
return _decoTime
elif flag=="double":
def _decoTime(func):
@wraps(func)
def retFunc(*args, **kw):
start = time()
func(*args, **kw)
func(*args, **kw)
now = time()
print("spend time:{:.2f}".format(now-start))
print("func_name: {}".format(func.__name__))
return retFunc
return _decoTime
@decoTime("normal")
def myfunc1():
sleep(2)
@decoTime("double")
def myfunc2():
sleep(2)
myfunc1()
myfunc2()
执行效果：
spend time:2.00
func_name: myfunc1
spend time:4.01
func_name: myfunc2
说实话，这种带参数的装饰器相当ugly，三层嵌套。
singledispatch
singledispatch是用来实现单分派的装饰器，一个比较实用的装饰器，用来实现类似C++中的重载功能或者说解决函数中if-else过多的问题，简单通过下面的code可以说明：
from functools import singledispatch
@singledispatch
def fun(arg, verbose=False):
print(arg)
@fun.register(int)
def _(arg, verbose=False):
print(type(arg))
print(arg)
@fun.register(list)
def _(arg, verbose=False):
print(type(arg))
for i, elem in enumerate(arg):
print(i, elem)
fun(123)
fun(['a', 'b', 'c'])
执行结果：
<class 'int'>
123
<class 'list'>
0 a
1 b
2 c
这里分别为fun注册了两个匿名函数，根据入参的类型，执行不同的函数。
lru_cathe
装饰器lru_cathe是使用lru缓存算法(底层采用key-value保存结果)为函数结果保存结果，这样重复调用函数时，会使用之前缓存的结果，而不会重复计算：
from functools import lru_cache
cnt1 = 0
def fib1(n):
global cnt1
cnt1 = cnt1 + 1
if n < 2:
return n
return fib1(n-1) + fib1(n-2)
cnt2 = 0
@lru_cache(maxsize=None)
def fib2(n):
global cnt2
cnt2 = cnt2 + 1
if n < 2:
return n
return fib2(n-1) + fib2(n-2)
fib1(5)
fib2(5)
print("cnt1 : %d" %cnt1)
print("cnt2 : %d" %cnt2)
执行结果：
cnt1 : 15
cnt2 : 6
其中maxsize是用来指定lru的最大缓存大小，默认是128，如果设置为None缓存大小为无穷大。当然官方API建议，当maxsize大小为2的指数时效率最高。
小结
对于python，经常面试的时候都会问到装饰器相关的内容，其实也有大牛建议使用__call__来代替装饰器的使用，其实工具的使用在于场景，但是脑袋需要知道有这些工具才能有机会比较，不然...google呀！
