Python基础（五）装饰器
装饰器
装饰器，迭代器，生成器都是十分重要的高级函数。本节开始说装饰器
一、基础
掌握装饰器必须掌握的三个基础
1.1、作用域 LEGB
这个之前说过 请参照http://www.cnblogs.com/wanstack/articles/6952751.html
1.2、函数即对象
在python的世界里，函数和我们之前的[1,2,3],'abc',8等一样都是对象，而且函数是最高级的对象（对象是类的实例化，可以调用相应的方法，函数是包含变量对象的对象，牛逼！）。
函数名是一个变量，可以被赋值，可以被当作参数，可以被当作返回值
1 def foo(): 2 print('i am the foo') 3 4 5 bar=foo 6 bar() 7 # i am the foo
带着这个问题，我们聊一聊函数在内存的存储情况：
图中 bar=foo表示变量bar指向了函数名foo的内存地址。
函数对象的调用仅仅比其它对象多了一个()而已！foo,bar与a,b一样都是个变量名。
只有函数加载到内存才可以被调用。
既然函数是对象，那么自然满足下面两个条件：
1.2.1 可以被赋给其他变量
1 def foo(): 2 print('foo') 3 bar=foo 4 bar() 5 foo() 6 print(id(foo),id(bar)) # 12895840 12895840
1.2.2 其可以被定义在另外一个函数内(作为参数&作为返回值),类似于整形，字符串等对象。
1 # 函数名作为参数 2 def foo(func): 3 print('foo...') 4 func() 5 def bar(): 6 print('bar...') 7 foo(bar) 8 """ 9 foo... 10 bar... 11 """
1 # 函数名作为返回值 2 def foo(): 3 print('foo...') 4 return bar 5 6 def bar(): 7 print('bar...') 8 9 b = foo() 10 b() 11 """ 12 foo... 13 bar... 14 """
注意：这里说的函数都是指函数名，比如foo；而foo()已经执行函数了，foo()是什么类型取决于return的内容是什么类型！！！
另外，如果大家理解不了对象，那么就将函数理解成变量，因为函数对象总会由一个或多个变量引用，比如foo，bar。
1.3、函数的嵌套以及闭包
先来看一下例子：
1 def foo(): 2 print('foo') 3 def bar() 4 print('bar..') 5 bar() # 报错 bar也是一个变量，存在于local的作用域在global作用域中不能被引用
再来看一下例子：
1 def foo(): 2 x = 1 3 def bar(): 4 print(x) 5 return bar 6 f = foo() 7 f() # 1
上面这个例子bar函数可以被正常执行了。
如果直接执行bar()肯定会报错，上上个例子有说明
这里的f=foo()是什么意思，其实就是一个变量赋值。即f=bar，因为foo()的返回值是bar,f()，也就是bar()
执行到这里都没问题。问题是下面的例子：
1 def outer(): 2 x=1 #函数outer执行完毕即被销毁 3 print(x)
上面执行print(x)的时候是会报错的。但是结合上上个例子，f=foo()，执行了函数所以函数foo中的x也已经被销毁了，但是函数bar中为什么还能正常引用函数foo中的x呢？
这就涉及到我们叫讲的闭包啦！
因为：foo里return的bar是一个闭包函数，有x这个环境变量。
OK，那么什么是闭包呢？
闭包(closure)是函数式编程的重要的语法结构。
定义：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).
如上实例，bar就是内部函数，bar里引用了外部作用域的变量x（x在外部作用域foo里面，不是全局作用域），
则这个内部函数bar就是一个闭包。
再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，inner就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。
1 # 用途1：当闭包执行完后，仍然能够保持住当前的运行环境。 2 # 比如说，如果你希望函数的每次执行结果，都是基于这个函数上次的运行结果。我以一个类似棋盘游戏的例子 3 # 来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向 4 # (direction)，步长(step)，该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外， 5 # 当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标。 6 7 origin = [0, 0] # 坐标系统原点 8 legal_x = [0, 50] # x轴方向的合法坐标 9 legal_y = [0, 50] # y轴方向的合法坐标 10 def create(pos=origin): 11 def player(direction,step): 12 # 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等 13 # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。 14 new_x = pos[0] + direction[0]*step 15 new_y = pos[1] + direction[1]*step 16 pos[0] = new_x 17 pos[1] = new_y 18 #注意！此处不能写成 pos = [new_x, new_y]，原因在上文有说过 19 return pos 20 return player 21 22 player = create() # 创建棋子player，起点为原点 23 print (player([1,0],10)) # 向x轴正方向移动10步 24 print (player([0,1],20)) # 向y轴正方向移动20步 25 print (player([-1,0],10)) # 向x轴负方向移动10步 26 27 用途1
1 # 用途2：闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以 2 # 修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先 3 # 要提取出这些特殊行。 4 5 def make_filter(keep): 6 def the_filter(file_name): 7 file = open(file_name) 8 lines = file.readlines() 9 file.close() 10 filter_doc = [i for i in lines if keep in i] 11 """ 12 for i in lines: 13 if keep in i: 14 filter_doc = i 15 """ 16 return filter_doc 17 return the_filter 18 19 # 如果我们需要取得文件"result.txt"中含有"pass"关键字的行，则可以这样使用例子程序 20 filter = make_filter("pass") 21 filter_result = filter("result.txt")
二、装饰器
装饰器本质上是一个函数，该函数用来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
场景：
1 def foo(): 2 print('hello foo') 3 foo()
现在有一个新的需求，希望可以记录下函数的执行时间，于是在代码中添加日志代码：
1 import time 2 def foo(): 3 start_time=time.time() # 时间戳，林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数
4 print('hello foo') 5 time.sleep(3) 6 end_time=time.time() 7 print('spend %s'%(end_time-start_time)) 8 9 foo()
bar()、bar2()也有类似的需求，怎么做？再在bar函数里调用时间函数？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门设定时间:
1 import time 2 def show_time(func): 3 start_time=time.time() 4 func() 5 end_time=time.time() 6 print('spend %s'%(end_time-start_time)) 7 8 9 def foo(): 10 print('hello foo') 11 time.sleep(3) 12 13 show_time(foo)
逻辑上不难理解，而且运行正常。 但是这样的话,你基础平台的函数修改了名字，容易被业务线的人投诉的，因为我们每次都要将一个函数作为参数传递给show_time函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行foo()，但是现在不得不改成show_time(foo)。那么有没有更好的方式的呢？当然有，答案就是装饰器。
2.1 简单装饰器
if foo()==show_time(foo) :问题解决!
怎么能使得他们相等呢，很显然嵌套函数可以实现，类似下面的这种
1 def bar(): 2 print('bar..') 3 4 def outer(func): 5 def inner(): 6 print('inner') 7 func() 8 return inner 9 10 bar=outer(bar) 11 bar()
我们之前是执行的bar(),现在要对函数bar进行扩展。让他可以打印执行的时间。问题是不能在原函数bar上做任何的修改。基于上面的方式，我们可以写出如下装饰器
1 def bar(): 2 print('bar..') 3 time.sleep(1) 4 5 import time 6 def outer(func): 7 def inner(): 8 start_time=time.time() 9 func() 10 end_time=time.time() 11 print('spend:%s' %(end_time-start_time)) 12 return inner 13 14 bar=outer(bar) # 这里其实是把inner赋值给bar了。执行bar(),就是执行inner(),所以还是很简单的 15 bar() 16 """ 17 bar.. 18 spend:1.000206708908081 19 """
函数outer就是装饰器，它把真正的业务方法func包裹在函数里面，看起来像bar被上下时间函数装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作
1 import time 2 def outer(func): 3 def inner(): 4 start_time=time.time() 5 func() 6 end_time=time.time() 7 print('spend:%s' %(end_time-start_time)) 8 return inner 9 10 @outer # 装饰器语法糖 == bar=outer(bar) 11 def bar(): 12 print('bar..') 13 time.sleep(1) 14 15 bar() 16 """ 17 bar.. 18 spend:1.000206708908081 19 """
如上所示，这样我们就可以省去bar = outer(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
这里需要注意的问题： bar=bar(foo)其实是把inner引用的对象引用给了bar，而inner里的变量func之所以可以用，就是因为inner是一个闭包函数。
@show_time帮我们做的事情就是当我们执行业务逻辑foo()时，执行的代码由粉框部分转到蓝框部分，仅此而已！
装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。
2.2 修改带参数的函数
上面是最简单的装饰器，如果被修改的函数有参数怎么办，理解了上面的过程，我想很简单
1 import time 2 def show_time(func): 3 def wrapper(a, b): 4 start_time = time.time() 5 func(a, b) 6 end_time = time.time() 7 print('spend %s' % (end_time - start_time)) 8 return wrapper 9 10 @show_time # add=show_time(add) 11 def add(a, b): 12 time.sleep(1) 13 print(a + b) 14 15 add(2, 4)
被修饰的函数是不定长参数
1 #***********************************不定长参数 2 import time 3 4 def show_time(func): 5 6 def wrapper(*args,**kwargs): 7 start_time=time.time() 8 func(*args,**kwargs) 9 end_time=time.time() 10 print('spend %s'%(end_time-start_time)) 11 12 return wrapper 13 14 @show_time #add=show_time(add) 15 def add(*args,**kwargs): 16 17 time.sleep(1) 18 sum=0 19 for i in args: 20 sum+=i 21 print(sum) 22 23 add(2,4,8,9)
2.3 带参数的装饰器
装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@show_time，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
1 import time 2 def time_logger(flag=0): 3 def show_time(func): 4 def wrapper(*args, **kwargs): 5 start_time = time.time() 6 func(*args, **kwargs) 7 end_time = time.time() 8 print('spend %s' % (end_time - start_time)) 9 10 if flag: 11 print('将这个操作的时间记录到日志中') 12 13 return wrapper 14 15 return show_time 16 17 18 @time_logger(3) 19 def add(*args, **kwargs): 20 time.sleep(1) 21 sum = 0 22 for i in args: 23 sum += i 24 print(sum) 25 26 27 add(2, 7, 5)
@time_logger(3) 执行的过程：
（1）先执行time_logger(3)：得到闭包函数show_time，里面保存环境变量flag
（2）再执行@show_time 另一种写法是：add＝show_time(add) 这种写法不能更改。
上面的time_logger是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器(一个含有参数的闭包函数)。当我 们使用@time_logger(3)调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。
为什么带参数的装饰器需要在原有的装饰器上再封装一层，难道仅仅是得到闭包函数。让带装饰器的参数可以正常的再原有装饰器函数中得到引用？？？？？？
所以为什么需要三层嵌套： 原因1： @show_time的写法固定就是恒等于 add=show_time(add)，在此基础上需要对@show_time增加参数，也就是show_time('参数')（add）所以需要增加一层函数对装饰器进行封装，并且返回的是一个装饰器也就是show_time（'参数'）的return 装饰器，然后@装饰器
2.4 多层装饰器
1 def makebold(fn): 2 def wrapper(): 3 return "<b>" + fn() + "</b>" 4 5 return wrapper 6 7 8 def makeitalic(fn): 9 def wrapper(): 10 return "<i>" + fn() + "</i>" 11 12 return wrapper 13 14 15 @makebold 16 @makeitalic 17 def hello(): # 从下面的图中可以看到，先执行@makeitalic,然后返回执行装饰器makeitalic中的wrapper，然后执行@makebold,第二个装饰器是用来装饰makeitalic中的wrapper函数的。
18 return "hello alvin" 19 20 21 print(hello())
1 # 装饰器的顺序 2 3 @a 4 @b 5 @c 6 def f (): 7 8 # 等效于 9 10 f = a(b(c(f)))
2.5 类装饰器
再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
1 import time 2 3 class Foo(object): 4 def __init__(self, func): 5 self._func = func 6 7 def __call__(self): 8 start_time=time.time() 9 self._func() 10 end_time=time.time() 11 print('spend %s'%(end_time-start_time)) 12 13 @Foo #bar=Foo(bar) # 这里相当于对类进行实例化操作，参数是变量bar 14 15 def bar(): 16 17 print ('bar') 18 time.sleep(2) 19 20 bar() #bar=Foo(bar)()>>>>>>>没有嵌套关系了,直接active Foo的 __call__方法
2.6 functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
1 def foo(): 2 print("hello foo") 3 4 print(foo.__name__) 5 6 def logger(fun): 7 def wrapper(): 8 fun() 9 return wrapper 10 11 @logger #bar=logger(bar) 12 def bar(): 13 print('hello') 14 15 print(bar.__name__) # 这里的bar.__name__改变成了wrapper了
解释：
1 @logger #bar=logger(bar) 2 def bar(): 3 print('hello')
等价于：
1 def bar(): 2 print('hello') 3 4 bar=logger(bar)
不难发现，函数bar被wrapper取代了，当然它的docstring，__name__就是变成了wrapper函数的信息了。
1 print f.__name__ # prints 'wrapper' 2 print f.__doc__ # prints None
这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。
1 def logger(fun): 2 @wraps(fun) 3 def wrapper(): 4 fun() 5 return wrapper 6 7 @logger #bar=logger(bar) 8 def bar(): 9 print('hello') 10 11 print(bar.__name__) # bar 这里名字改变过来了
2.7 内置装饰器
@staticmathod
@classmethod
@property
未完后续补充
2.8 补充
1 #foo函数先加载到内存,然后foo变量指向新的引用,所以函数里的foo是wrapper函数对象 2 def show_time(func): 3 4 def wrapper(n): 5 ret=func(n) 6 print("hello,world") 7 return ret 8 return wrapper 9 10 @show_time # foo=show_time(foo) 11 def foo(n): 12 if n==1: 13 return 1 14 return n*foo(n-1) 15 print(foo(6))
1 def show_time(func): 2 3 def wrapper(n): 4 ret=func(n) 5 print("hello,world") 6 return ret 7 return wrapper 8 9 @show_time# foo=show_time(foo) 10 def foo(n): 11 def _foo(n): 12 if n==1: 13 return 1 14 return n*_foo(n-1) 15 return _foo(n) 16 print(foo(6))
未完待续【内置装饰器】
浙公网安备 33010602011771号