web-装饰器

装饰器是程序开发中经常会用到的一个功能，用 好了装饰器，开发效率如虎添翼。

写代码要遵循开放封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

封闭：已实现的功能代码块

开放：对扩展开发

先明白这段代码

第一波

def foo():
print(‘foo’)

foo # 表示是函数
foo() # 表示执行foo函数

第二波

def foo():
print(‘foo’)

foo = lambda x: x + 1

foo() # 执行lambda表达式，而不再是原来的foo函数，因为foo这个名字被重新指向了另外一个匿名函数，函数名仅仅是个变量，只不过指向了定义的函数而已，所以才能通过 函数名()调用，如果 函数名=xxx被修改了，那么当在执行 函数名()时，调用的就不知之前的那个函数了

def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
func()
return inner

@w1
def f1():
print(‘f1’)
@w1
def f2():
print(‘f2’)
@w1
def f3():
print(‘f3’)
@w1
def f4():
print(‘f4’)

对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其无需做任何操作。

单独以f1为例

def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
func()
return inner

@w1
def f1():
print(‘f1’)

python解释器就会从上到下解释代码，步骤如下：
def w1(func): ==>将w1函数加载到内存
@w1
没错， 从表面上看解释器仅仅会解释这两句代码，因为函数在 没有被调用之前其内部代码不会被执行。

从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章， @函数名 是python的一种语法糖。

上例@w1内部会执行一下操作：

执行w1函数 ，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1) 所以，内部就会去执行：

def inner():
#验证 1
#验证 2
#验证 3
f1() # func是参数，此时 func 等于 f1
return inner # 返回的 inner，inner代表的是函数，非执行函数 ,其实就是将原来的 f1 函数塞进另外一个函数中

w1的返回值
将执行完的w1函数返回值 赋值 给@w1下面的函数的函数名f1 即将w1的返回值再重新赋值给 f1，即：

新f1 = def inner():
#验证 1
#验证 2
#验证 3
原来f1()
return inner
所以，想要执行 f1 函数时，就会执行 新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。

装饰器示例:例1:无参数的函数

from time import time, sleep # 导包
def timefun(func):
def wrapped_func():
print(“%s called at %s” % (func.name, time()))
func()
return wrapped_func

@timefun
def foo():
print(“I am foo”)

foo()
sleep(2)
foo()

上面代码理解装饰器执行行为可理解成

foo = timefun(foo)

foo先作为参数赋值给func后,foo接收指向timefun返回的wrapped_func

foo()

调用foo(),即等价调用wrapped_func()

内部函数wrapped_func被引用，所以外部函数的func变量(自由变量)并没有释放

func里保存的是原foo函数对象

例2:被装饰的函数有参数

from time import ctime, sleep

def timefun(func):
def wrapped_func(a, b):
print(“%s called at %s” % (func.name, ctime()))
print(a, b)
func(a, b)
return wrapped_func

@timefun
def foo(a, b):
print(a+b)

foo(3,5)
sleep(2)
foo(2,4)

例3:被装饰的函数有不定长参数

from time import ctime, sleep

def timefun(func):
def wrapped_func(*args, **kwargs):
print(“%s called at %s”%(func.name, ctime()))
func(*args, **kwargs)
return wrapped_func

@timefun
def foo(a, b, c):
print(a+b+c)

foo(3,5,7)
sleep(2)
foo(2,4,9)

例4:装饰器中的return

from time import ctime, sleep

def timefun(func):
def wrapped_func():
print(“%s called at %s” % (func.name, ctime()))
func()
return wrapped_func

@timefun
def foo():
print(“I am foo”)

@timefun
def getInfo():
return ‘—-hahah—’

foo()
sleep(2)
foo()

print(getInfo())
执行结果:

foo called at Fri Nov 4 21:55:35 2016
I am foo
foo called at Fri Nov 4 21:55:37 2016
I am foo
getInfo called at Fri Nov 4 21:55:37 2016
None
如果修改装饰器为return func()，则运行结果：

foo called at Fri Nov 4 21:55:57 2016
I am foo
foo called at Fri Nov 4 21:55:59 2016
I am foo
getInfo called at Fri Nov 4 21:55:59 2016
—-hahah—
总结：
一般情况下为了让装饰器更通用，可以有return

例5:装饰器带参数,在原有装饰器的基础上，设置外部变量

from time import ctime, sleep

def timefun_arg(pre=”hello”):
def timefun(func):
def wrapped_func():
print(“%s called at %s %s” % (func.name, ctime(), pre))
return func()
return wrapped_func
return timefun

下面的装饰过程

1. 调用timefun_arg(“itcast”)

2. 将步骤1得到的返回值，即time_fun返回， 然后time_fun(foo)

3. 将time_fun(foo)的结果返回，即wrapped_func

4. 让foo = wrapped_fun，即foo现在指向wrapped_func

@timefun_arg(“itcast”)
def foo():
print(“I am foo”)

@timefun_arg(“python”)
def too():
print(“I am too”)

foo()
sleep(2)
foo()

too()
sleep(2)
too()
可以理解为
foo()==timefun_arg(“itcast”)(foo)()：