流畅的python，Fluent Python 第七章笔记
函数装饰器于闭包。
装饰器于闭包前面我前面已经有简单的记录，这次我根据书中内容，对函数装饰器重新于闭包做个简要笔记。
def deco(func):
def inner():
print('running inner()')
return inner
@deco
def target():
print('running target')
# target()
'''下面的等于上面的'''
target = deco(target)
target()
这个是对装饰器的语法糖函数的直接认识，你运行的被装饰的函数，其实已经是装饰器内部的函数。
7.2Python何时执行装饰器
registry = [] def register(func): print('running register(%s)' % func) registry.append(func) return func # 务必记得返回原函数 @register def f1(): print('running f1()') @register def f2(): print('running f2()') def f3(): print('running f3()') def main(): print('running main()') print('registry', registry) f1() f2() f3() if __name__ == '__main__': main()
running register(<function f1 at 0x10501f9e0>) running register(<function f2 at 0x10501fd40>) running main() registry [<function f1 at 0x10501f9e0>, <function f2 at 0x10501fd40>] running f1() running f2() running f3()
from t7_2 import *
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第七章/t.py running register(<function f1 at 0x10cd570e0>) running register(<function f2 at 0x10cd57050>) Process finished with exit code 0
上面两种执行，一种主函数执行，一种导入该模块。
装饰器函数在导入时立即执行，被装饰的函数只在明确调用时运行。
主函数也一样也时一样的原理。
第六章讲过的优惠方案函数就可以通过装饰器的方式，将所有的优惠方案函数放入一个列表当中，所有来看，这个应该时非常不错的选择
promos = []
def promotion(promo_func):
promos.append(promo_func)
return promo_func
需要添加的优惠方案用这个装饰器装饰，就会把优惠方案函数放入promos
是个非常不错的选择。
7.4变量作用域规则。
这个其实对我还时有比较深刻的印象的。
比较颠覆我的思想时，并不是什么函数的内部变量不能改变外部变量（不可变对象）（其实并不是内部变量不能改变外部变量，底层的原因就是如果你未在函数内部赋值改变量假设x，你如果执行x = x + 1，在编辑器运行中，这个赋值语句将会把x定义为局部变量，然而你在内部函数中都未有x，所有肯定报错，这个才是所谓内部变量不能改变外部变量的原因。假如你在内部函数体赋值了x=1，那更加直接的告诉了编辑器，这个是局部变量，根本不可能改变外部的全局变量x），而是函数在执行前，编辑器会先判断在函数体内部的赋值，不管在哪个位置赋值，
一旦有赋值，则该变量将变成局部变量，在函数内部的参数调用中，将使用该局部变量。
如果外部有已经赋值的变量，函数内部没有该变量，可以引用该变量，但不能修改该变量内容（不可变对象），除非你在函数体内定义global变量为全局变量。
import dis
a = 1
c = 2
def fn(arg):
print(a)
print(arg)
print(c)
c = 3
if __name__ == '__main__':
print(dis.dis(fn))
fn(99)
上面的函数外部已经定义了c，但函数内部也定义了c，所以在编译函数体中，将c定义为局部变量，由于函数内部print（c）在c=3之前，所以对于print函数来说，c就是一个未定义的对象。
Traceback (most recent call last):
File "/Users/shijianzhong/study/Fluent_Python/第七章/t7_4.py", line 12, in <module>
fn(99)
File "/Users/shijianzhong/study/Fluent_Python/第七章/t7_4.py", line 7, in fn
print(c)
UnboundLocalError: local variable 'c' referenced before assignment
5 0 LOAD_GLOBAL 0 (print)
2 LOAD_GLOBAL 1 (a)
4 CALL_FUNCTION 1
6 POP_TOP
6 8 LOAD_GLOBAL 0 (print)
10 LOAD_FAST 0 (arg)
12 CALL_FUNCTION 1
14 POP_TOP
7 16 LOAD_GLOBAL 0 (print)
18 LOAD_FAST 1 (c) # c为局部函数
20 CALL_FUNCTION 1
22 POP_TOP
8 24 LOAD_CONST 1 (3)
26 STORE_FAST 1 (c)
28 LOAD_CONST 0 (None)
30 RETURN_VALUE
None
1
99
解决方法有很多，
1、可以在顶部定义 global c
2、在函数体内部删除c=3，直接引用全局变量
3、将c=3移到print（c）之前，就可以调用局部参数c了
7.5闭包
书中的翻译，闭包指的是延伸了作用域的函数，其中包含函数定义体中引用、但是不在定义体定义的非全局变量。
这个不知道是翻译不好，还是我的理解有问题，好拗口。
做到后面刚好可以理解了，就是一个函数，有一个变量，函数体里面引用了，但这个变量为非全局变量，而且不在这个函数体内部定义的。
重点的重点
1、不在定义体定义
2、非全局变量
3、函数定义体引用
下面用了一个求平均值的方法来做案例，分别用了类于高阶函数（复习高阶函数定义，能接收函数对象的，或者返回为函数的都叫高阶函数）
class Averager:
def __init__(self):
self.series = []
def __call__(self, new_value):
self.series.append(new_value)
total = sum(self.series)
return total / len(self.series)
avg = Averager()
print(avg(3))
print(avg(4))
print(avg(5))
通过类的调用，很简单。
通过闭包的使用，稍微理解复杂一点。
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total / len(series)
return averager
avg = make_averager()
print(avg(3))
print(avg(4))
print(avg(5))
print(avg.__code__.co_varnames) # 局部变量名
print(avg.__code__.co_freevars) # 自由变量，就是series
print(avg.__closure__[0].cell_contents) # 取出series内的内容。
'''闭包是一个函数，它会保留定义函数时存在的自由变量的绑定，这样调用
函数时，虽然定义作用域不可用了，但是仍能使用那些绑定'''
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第七章/t7_9.py
3.0
3.5
4.0
('new_value', 'total')
('series',)
[3, 4, 5]
Process finished with exit code 0
7.6nonlocal声明
nonlocal感觉就是为闭包使用的，当闭包函数绑定的自由变量为不可变类型参数时，就需要nonlocal了。
def make_averager():
count = 0
total = 0
def averager(new_value):
nonlocal count, total # 其实是将变量标记为自由变量
count += 1
total += new_value
return total / count
return averager
avg = make_averager()
print(avg(3))
print(avg(4))
print(avg(5))
print(avg.__code__.co_varnames) # 局部变量名
print(avg.__code__.co_freevars) # 自由变量，就是series
print([i.cell_contents for i in avg.__closure__]) # 取出series内的内容。
'''闭包是一个函数，它会保留定义函数时存在的自由变量的绑定，这样调用
函数时，虽然定义作用域不可用了，但是仍能使用那些绑定'''
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第七章/t7_13.py
3.0
3.5
4.0
('new_value',)
('count', 'total')
[3, 12]
Process finished with exit code 0
标记为自由变量后，就可以对该函数的附属值（不可变对象）进行重新创建。
7.7 实现一个简单的装饰器
根据我在敲代码过程中的思考，函数装饰器肯定就是一种闭包函数，满足闭包函数的所有条件。
装饰器内部的函数，运行的就是不在函数内部定义的非全局变量（因为通过外部的函数传递进来，编程局部变量），而且还对其进行了引用，（其实就是运行被装饰的函数。）
# t7_15.py
import time
from functools import wraps
def clock(func):
@wraps(func) # 把被装饰的函数的属性__doc__与__name__属性转移到装饰器内部函数
def clocked(*args):
t0 = time.perf_counter()
result = func(*args)
elapsed = time.perf_counter() - t0
name = func.__name__
arg_src = ', '.join(repr(arg) for arg in args)
print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_src, result))
return result
return clocked
import time
from t7_15 import clock
@clock
def snooze(seconds):
'''This is snooze'''
time.sleep(seconds)
'''根据闭包的解释闭包指的是延伸了作用域的函数
，其中包含函数定义体中引用、但是不在定义体定义的非全局变量。
这个snooze函数里面包含了<function snooze at 0x10c0feb90>，
就是snooze原来的函数，这个就是不在函数定义体定义的非全局变量。
但具体又要执行，包含了定义体中的引用。
'''
@clock
def factorial(n):
return 1 if n < 2 else n * factorial(n-1)
if __name__ == '__main__':
print(snooze.__name__)
print(snooze.__doc__)
print(snooze.__code__.co_name)
print(snooze.__closure__[0].cell_contents)
print(factorial.__closure__[0].cell_contents)
print('*' * 40)
snooze(.123)
print(factorial(6))
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第七章/t7_16.py t7_15 snooze This is snooze clocked <function snooze at 0x10ed97b90> <function factorial at 0x10ed48200> **************************************** [0.12730196s] snooze(0.123) -> None [0.00000109s] factorial(1) -> 1 [0.00002362s] factorial(2) -> 2 [0.00003878s] factorial(3) -> 6 [0.00005274s] factorial(4) -> 24 [0.00006689s] factorial(5) -> 120 [0.00008470s] factorial(6) -> 720 720 Process finished with exit code 0
7.8标准库中的装饰器
7.8.1functool.lru_cahe
@functools.lru_cache(maxsize=128, typed=True) # maxsize保存最多的缓存值，满了以后旧的扔掉
@clock # typed设置为true,可以把不同参数类型分开保存，列如1和1.0分开
def deco(x, y):
print(f'x is {x},y is {y}')
return x + y
@functools.lru_cache()
@clock
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 2) + fibonacci(n - 1)
deco(1, 2)
deco(1, 2)
deco(2, 3)
deco(2, 3)
fibonacci(10) # 可以起到加速的作用
x is 1,y is 2 [0.00001129s] deco(1, 2) -> 3 x is 2,y is 3 [0.00000936s] deco(2, 3) -> 5 [0.00000091s] fibonacci(0) -> 0 [0.00000081s] fibonacci(1) -> 1 [0.00003022s] fibonacci(2) -> 1 [0.00000161s] fibonacci(3) -> 2 [0.00005840s] fibonacci(4) -> 3 [0.00000134s] fibonacci(5) -> 5 [0.00008966s] fibonacci(6) -> 8 [0.00000139s] fibonacci(7) -> 13 [0.00011810s] fibonacci(8) -> 21 [0.00000135s] fibonacci(9) -> 34 [0.00014750s] fibonacci(10) -> 55
缓存里面已经有计算结果的值，就不重新执行了，所以相对来说运算速度快了很多，避免了很多重复运算。
7.8.2 单分派泛函数
我从书中的案例理解，可以将一个函数注册给不同的子类，子类根据传入的参数性质分别进去不同的定义函数，如果子函数没有，就执行主装饰函数。
from functools import singledispatch
from collections import abc
import numbers
import html
@singledispatch
def htmlize(obj):
content = html.escape(repr(obj))
return '<pre>{}</pre>'.format(content)
@htmlize.register(str) # 字符串进这里
def _(text):
content = html.escape(text).replace('\n', '<br>\n')
return '<p>{}</p>'.format(content)
@htmlize.register(numbers.Integral) # 数字进这里
def _(n):
return '<pre>{0} (0x{0:x})</pre>'.format(n)
@htmlize.register(tuple) # 元祖进这里
@htmlize.register(abc.MutableSequence) # 可变序列进这里
def _(seq):
inner = '</li>\n<li>'.join(htmlize(item) for item in seq)
return '<ul>\n<li>' + inner +'</li>\n</ul>'
In [40]: from t7_21 import htmlize
In [41]: htmlize({1,2,3})
Out[41]: '<pre>{1, 2, 3}</pre>'
In [42]: htmlize(abs)
Out[42]: '<pre><built-in function abs></pre>'
In [43]: htmlize('Heimlich & Co.\n -a game')
Out[43]: '<p>Heimlich & Co.<br>\n -a game</p>'
In [44]: htmlize(42)
Out[44]: '<pre>42 (0x2a)</pre>'
In [45]: htmlize(['alpha',66,{3,2,1}])
Out[45]: '<ul>\n<li><p>alpha</p></li>\n<li><pre>66 (0x42)</pre></li>\n<li><pre>{1, 2, 3}</pre></li>\n</ul>'
打个不合适的比方，@singledispatch有点像父亲，注册了很多子函数，需要注册在父亲之下。
这个比用if的话，可以降低函数之间的耦合程度。
带参数的函数装饰器最外层的函数就是一个制造装饰器的函数。
7.10.2参数化clock装饰器
# t7_25.py
import time
from functools import wraps
DEFAULT_LMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'
def clock(fmt = DEFAULT_LMT):
def decorate(func):
@wraps(func) # 把被装饰的函数的属性__doc__与__name__属性转移到装饰器内部函数
def clocked(*args):
t0 = time.perf_counter()
result = func(*args)
elapsed = time.perf_counter() - t0
name = func.__name__
arg_src = ', '.join(repr(arg) for arg in args)
print(fmt.format(**locals())) # 通过**locals()解包来传递格式化参数，真的非常骚操作。
return result
return clocked
return decorate
if __name__ == '__main__':
# 只需要在clock()函数的参数内填写需要格式化输出的样式，就可以根据自己喜欢的形式输出
@clock()
def snooze(seconds):
time.sleep(seconds)
for i in range(3):
snooze(.123)
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第七章/t7_25.py [0.12805624s] snooze((0.123,)) -> None [0.12805513s] snooze((0.123,)) -> None [0.12333814s] snooze((0.123,)) -> None Process finished with exit code 0
