python——装饰器

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象，它经常用于有切面需求的场景，比如:插入日志、性能测试事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

举例：初创公司有N个业务部⻔，基础平台部⻔负责提供底层的功能，如：数据库 操作、redis调⽤、监控API等功能。业务部⻔使⽤基础功能时，只需调⽤基础平台提供的功能即可。如下：

############### 基础平台提供的功能如下 ###############
def f1():
    print('f1')
def f2():
    print('f2')
def f3():
    print('f3')
def f4():
    print('f4')
############### 业务部⻔A 调⽤基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 业务部⻔B 调⽤基础平台提供的功能 ###############
f1()
f2()
f3()
f4()

结果：

f1
f2
f3
f4
f1
f2
f3
f4

问题：以前基础平台的开发⼈员在写代码时候 没有关注验证相关的问题，即：基础平台的提供的功能可以被任何⼈使⽤。 现在需要对基础平台的所有功能进⾏重构，为平台提供的所有功能添加验证 机制，即：执⾏功能前，先进⾏验证。

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

• 封闭：已实现的功能代码块
• 开放：对扩展开发

如果将开放封闭原则应⽤在上述需求中，那么就不允许在函数 f1 、f2、f3、 f4的内部进⾏修改代码。

@符号是装饰器的语法，在定义函数的时候使用，避免再一次赋值操作。

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')

############### 业务部⻔A 调⽤基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 业务部⻔B 调⽤基础平台提供的功能 ###############
f1()
f2()
f3()
f4()

内部执行原理：

1. def w1(func): ==>将w1函数加载到内存

2. @w1，@w1内部会执⾏以下操作：

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

def inner():
    #验证 1
    #验证 2
    #验证 3
    f1() # func是参数，此时 func 等于 f1
return inner# 返回的 inner，inner代表的是函数，⾮执⾏函数

装饰器示例：

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
def foo():
    print("I am foo")
foo()
sleep(2)
foo()

 结果：

foo called at Sat Apr 24 21:58:58 2021
I am foo
foo called at Sat Apr 24 21:59:00 2021
I am 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)

结果：

foo called at Sat Apr 24 22:07:44 2021
3 5
8
foo called at Sat Apr 24 22:07:46 2021
2 4
6 

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)

结果：

foo called at Sat Apr 24 22:13:16 2021
15
foo called at Sat Apr 24 22:13:18 2021
15 

4.装饰器中的return

⼀般情况下为了让装饰器更通⽤，可以有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 Sat Apr 24 22:16:00 2021
I am foo
foo called at Sat Apr 24 22:16:02 2021
I am foo
getInfo called at Sat Apr 24 22:16:02 2021
None

如果修改装饰器为

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

则结果为： 

 foo called at Sat Apr 24 22:17:31 2021
I am foo
foo called at Sat Apr 24 22:17:33 2021
I am foo
getInfo called at Sat Apr 24 22:17:33 2021
----hahah---

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 tootoo")
foo()
sleep(2)
foo()
too()
sleep(2)
too()

结果：

foo called at Sat Apr 24 22:20:20 2021 itcast
I am foo
foo called at Sat Apr 24 22:20:22 2021 itcast
I am foo
too called at Sat Apr 24 22:20:22 2021 python
I am tootoo
too called at Sat Apr 24 22:20:24 2021 python
I am tootoo

可以理解为： foo()==timefun_arg("itcast")(foo)() 

6.类装饰器

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

class Test():
    def __call__(self):
        print('call me!')
t = Test()
t() #结果：call me!

类装饰器demo：

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()

结果：

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