Python装饰器，面试必问

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

举个例子：

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

@w1
def f1():
    print('f1')

python解释器就会从上到下解释代码，步骤如下：

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

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

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

执行w1函数

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

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

w1的返回值

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

新f1 = def inner(): 
            #验证 1
            #验证 2
            原来f1()
        return inner

即为原来的f1函数加上了验证功能。想要执行f1函数时，就会执行新的f1函数，在新的f1函数内部进行验证，验证完毕以后执行原f1函数，然后将原来f1函数的返回值返回给业务调用者。

装饰器(decorator)功能

1. 引入日志
2. 函数执行时间统计
3. 执行函数前预备处理
4. 执行函数后清理功能
5. 权限校验等场景
6. 缓存

装饰器示例

例1:无参数的函数

from time import ctime, sleep

def timefun(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        func()
    return wrapped_func

@timefun	# 相当于foo = timefun(foo)
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()			# 此时最后一句print(getinfo()) 无结果，因为此时没有return接收返回值
        # return func()  一般情况下为了让装饰器更通用，可以有return
    return wrapped_func

@timefun
def foo():
    print("I am foo")

@timefun
def getInfo():
    return '----hahah---'

foo()
sleep(2)
foo()


print(getInfo())

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

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))
        	if pre == "aaa":
        		print("a级权限")
        	elif pre == "bbb":
        		print("b级权限") 
            return func()
        return wrapped_func
    return timefun

# 下面的装饰过程
# 1. 调用timefun_arg("aaa")
# 2. 将步骤1得到的返回值，即time_fun返回， 然后time_fun(foo)
# 3. 将time_fun(foo)的结果返回，即wrapped_func
# 4. 让foo = wrapped_fun，即foo现在指向wrapped_func
@timefun_arg("aaa")
def foo():
    print("I am foo")

@timefun_arg("bbb")
def too():
    print("I am too")

foo()
sleep(2)
foo()

too()
sleep(2)
too()

可以理解为foo==timefun_arg("aaa")(foo)或
foo()==timefun_arg("aaa")(foo)()
运行结果：

foo called at Sun Apr  5 18:37:58 2020 aaa
a级权限
I am foo
foo called at Sun Apr  5 18:38:00 2020 aaa
a级权限
I am foo
too called at Sun Apr  5 18:38:00 2020 bbb
b级权限
I am too
too called at Sun Apr  5 18:38:02 2020 bbb
b级权限
I am too

类装饰器（扩展，非重点）

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 call() 方法，那么这个对象就是callable的。

class Test():
    def __call__(self):
        print('call me!')

t = Test()
t()  # call me

类装饰器例子：

class Test(object):
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s"%func.__name__)
        self.__func = func
    def __call__(self):
        print("---装饰器中的功能---")
        self.__func()
#说明：
#1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象
#   并且会把test这个函数名当做参数传递到__init__方法中
#   即在__init__方法中的属性__func指向了test指向的函数

#2. test指向了用Test创建出来的实例对象

#3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法

#4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用
#   所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体
@Test
def test():
    print("----test---")
test()
showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"

运行结果如下：

---初始化---
func name is test
---装饰器中的功能---
----test---

多个装饰器装饰同一个函数

def set_func_1(func):
	def call_func():
		# "<h1>haha</h1>"
		return "<h1>" + func() + "</h1>"
	return call_func

def set_func_2(func):
	def call_func():
		return "<td>" + func() + "</td>"
	return call_func


@set_func_1
@set_func_2
def get_str():
	return "haha"

print(get_str())

运行结果：

<h1><td>haha</td></h1>

多个装饰器对同一个函数进行装饰，
先装下边靠近函数的后装上边的，执行时从前往后

@aaa
@bbb
def test():
	pass

先装bbb再装aaa，先执行aaa再执行bbb
装饰的前提：装饰器下边是函数，故先装靠近函数的bbb