python面向对象进阶-装饰器_python面向对象装饰器

---

前言

装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼。因为装饰器是程序开发的基础知识，这个都不会，别跟人家说你会Python。
学习装饰器需要先了解什么是闭包，可以先看下我的另一篇文章 > python面向对象进阶-闭包

---

1. 先明白这段代码

#### 第一波 ####
def foo():
    print('foo函数')


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


#### 第二波 ####
def foo():
    print('foo函数')


foo = lambda x: x + 1

foo()  # 执行下面的lambda表达式，而不再是原来的foo函数，因为foo这个名字被重新指向了另外一个匿名函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

是不是很简单，很容易理解

---

2. 案例

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

############### 基础平台提供的功能如下 ###############

def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

def f4():
    print('f4')
1
2
3
4
5
6
7
8
9
10
11

############### 业务部门A 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()
1
2
3
4

############### 业务部门B 调用基础平台提供的功能 ###############

f1()
f2()
f3()
f4()
1
2
3
4

目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

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

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

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

单独以f1为例：

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

@w1
def f1():
    print('f1')
1
2
3
4
5
6
7
8
9
10
11

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

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

没错， 从表面上看解释器仅仅会解释这两句代码，因为函数在 没有被调用之前其内部代码不会被执行。

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

1. 装饰器代码运行逻辑解释

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

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

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

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

新f1 = def inner(): 
            # 验证函数 1
            # 验证函数 2
            # 验证函数 3
            原来f1()
        return inner
1
2
3
4
5
6

所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。

---

3. 多个装饰器

再来看下多个装饰器的执行顺序

# 定义函数：完成包裹数据
def makeBold(fn):
    print("调用加粗的装饰器")
    def wrapped1():
        print("----1---")
        return "<b>" + fn() + "</b>"
    print("加粗装饰完成")
    return wrapped1


# 定义函数：完成包裹数据
def makeItalic(fn):
    print("调用斜体的装饰器")
    def wrapped2():
        print("----2---")
        return "<i>" + fn() + "</i>"
    print("斜体装饰完成")
    return wrapped2


@makeBold
@makeItalic
def test():
    print("----3---")
    return "hello world-3"


print(test())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

当 print(test()) 被注释时，执行代码结果如下

调用斜体的装饰器
斜体装饰完成
调用加粗的装饰器
加粗装饰完成
1
2
3
4

当没有注释时，执行结果如下

调用斜体的装饰器
斜体装饰完成
调用加粗的装饰器
加粗装饰完成
----1---
----2---
----3---
<b><i>hello world-3</i></b>
1
2
3
4
5
6
7
8

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

1. def makeBold(fn): ==>将makeBold函数加载到内存
2. def makeItalic(fn): ==>将makeItalic函数加载到内存
3. @makeBold
4. @makeItalic

1. 多个装饰器装饰逻辑解释

上例@makeBold和@makeItalic内部会执行一下操作：

• 未找到传入函数，先暂停，往下执行@makeItalic

def wrapped2():
    print("----2---")
    return "<i>" + fn() + "</i>" # fn为下面被装饰的函数test
1
2
3

此时的test函数指向了wrapped2函数，即

新test = def wrapped2():
    		print("----2---")
    		return "<i>" + 原test() + "</i>"
1
2
3

再往下走，就会执行 print(“斜体装饰完成”) 此时已经执行了闭包外包的函数代码，即

def makeItalic(fn):
    print("调用斜体的装饰器") # 已执行
    def wrapped2():
        print("----2---")
        return "<i>" + fn() + "</i>"
    print("斜体装饰完成") # 已执行
    return wrapped2
1
2
3
4
5
6
7

• 因为@makeItalic有返回函数，然后再开始执行@makeBold

def wrapped1():
    print("----1---")
    return "<b>" + fn() + "</b>" # 此时的fn函数为被makeItalic装饰完成的 新test
1
2
3

此时的test函数指向了wrapped1函数，即

最新test = def wrapped1():
    		  print("----1---")
    		  return "<b>" + 新test + "</b>"
1
2
3

所以装饰顺序是从下往上，一层一层往上套函数，和包装快递一样，最外层的包装，最后包

2. 装饰完成，代码执行时逻辑解释

test函数执行操作：

• 找到最新装饰完成的函数，执行

def wrapped1():
    print("----1---") # 所以先打印   1
    return "<b>" + fn() + "</b>" # 此时的fn函数为被makeItalic装饰完成的 新test
1
2
3

此时执行过程先暂停，先寻找此 fn 指向的函数，然后执行

def wrapped2():
    print("----2---") # 所以第二打印  2
    return "<i>" + fn() + "</i>" # fn为下面被装饰的函数test
1
2
3

此时执行过程再次暂停，还要寻找此 fn 指向的函数，然后执行

def test():
    print("----3---") # 故最后打印 3
    return "hello world-3" # 执行完毕，返回 "hello world-3"
1
2
3

执行完毕，然后执行最后暂停的函数

def wrapped2():
    return "<i>" + fn() + "</i>" # 此时 fn 已经执行完毕，所以先外面添加一层i标签
    # 执行完毕，返回 "<i>hello world-3</i>"
1
2
3

执行完毕，然后再执行较先暂停的函数，即

def wrapped1():
    return "<b>" + fn() + "</b>" # 此时的 fn 已经执行完毕，返回的是"<i>hello world-3</i>"
    # 执行完毕 返回 "<b><i>hello world-3</i></b>"
1
2
3

故，最后打印出来的是

<b><i>hello world-3</i></b>
1

---

4. 装饰器示例

1. 无参数的函数

from time import ctime, sleep

def timefun(func):
    def wrappedfunc():
    	# 函数名.__name__用于获取函数的名称
        print("%s called at %s"%(func.__name__, ctime())) 
        func()
    return wrappedfunc

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

foo()
sleep(2)
foo()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

foo = timefun(foo)
#foo先作为参数赋值给func后,foo接收指向timefun返回的wrappedfunc
foo()
#调用foo(),即等价调用wrappedfunc()
#内部函数wrappedfunc被引用，所以外部函数的func变量(自由变量)并没有释放
#func里保存的是原foo函数对象
1
2
3
4
5
6

2. 被装饰的函数有参数

from time import ctime, sleep

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

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

foo(3,5)
sleep(2)
foo(2,4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果

foo called at Thu Oct 22 15:38:14 2020
3 5
8
foo called at Thu Oct 22 15:38:16 2020
2 4
6
1
2
3
4
5
6

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

from time import ctime, sleep


def timefun(func):
    def wrappedfunc(*args, **kwargs):
        print("%s called at %s" % (func.__name__, ctime()))
        func(*args, **kwargs)

    return wrappedfunc


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


foo(3, 5, 7)
sleep(2)
foo(2, 4, 9, name='test1')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果

foo called at Thu Oct 22 15:44:52 2020
15

foo called at Thu Oct 22 15:44:54 2020
15
test1
1
2
3
4
5
6

4. 装饰器中的return

from time import ctime, sleep

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

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

print(getInfo())
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果

getInfo called at Thu Oct 22 15:50:17 2020
None
1
2

因为装饰完成后，实际调用的是

def wrappedfunc():
    print("%s called at %s"%(func.__name__, ctime()))
    func()
    # 没有返回值，只是执行了getInfo()，没有保存并返回

def wrappedfunc():
    print("%s called at %s" % (func.__name__, ctime()))
    a = func()
    return a
    # 有返回值了，因为变量a保存了getInfo()的返回结果，然后函数返回a
1
2
3
4
5
6
7
8
9
10

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

from time import ctime, sleep

def timefun_arg(pre="hello"):
    def timefun(func):
        def wrappedfunc():
            print("%s called at %s %s"%(func.__name__, ctime(), pre))
            return func()
        return wrappedfunc
    return timefun

@timefun_arg("itcast") # 给装饰器的 pre 参数传参，并保存
def foo():
    print("I am foo")

@timefun_arg("python") # 给装饰器的 pre 参数传参，并保存
def too():
    print("I am too")

foo()
sleep(2)
foo()

too()
sleep(2)
too()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

可以理解为

foo()==timefun_arg("itcast")(foo)()
1

运行结果

foo called at Thu Oct 22 16:31:35 2020 itcast
I am foo
foo called at Thu Oct 22 16:31:37 2020 itcast
I am foo
too called at Thu Oct 22 16:31:37 2020 python
I am too
too called at Thu Oct 22 16:31:39 2020 python
I am too
1
2
3
4
5
6
7
8

---

总结

纯个人学习笔记，可能有部分逻辑理解不到位，望理解并指教