装饰器#

装饰器是给现有的模块增添新的小功能，可以对原函数进行功能扩展，而且还不需要修改原函数的内容，也不需要修改原函数的调用。

一切皆对象#

首先我们来理解下 Python 中的函数:

1
def hello(name):
2
    return "hello " + name
3

4
print(hello('White_mu'))
5
# 输出: 'hi White_mu'
6

7
# 我们甚至可以将一个函数赋值给一个变量，比如
8
hi = hello
9
# 我们尝试运行下这个
10
print(hi('White_mu'))
11
# output: 'hi White_mu'
12

13
# 如果我们删掉旧的hello函数，看看会发生什么！
14
del hello
15
print(hello('White_mu'))
16
#outputs: NameError
17

18
print(hi('White_mu'))
19
#outputs: 'hi White_mu'

在函数中定义函数#

这个好理解，我们可以在函数中继续定义一个函数，例如在A函数中定义一个B函数并调用，但B函数不能被外部调用

1
def main():
2
    def hello():
3
        print('hello')
4
    def bye():
5
        print('bye')
6
    hello()
7
    bye()
8

9
main()
10
#output: hello
11
#output: bye

在函数中返回函数#

这个也好理解，我们可以在父函数中返回父函数中的子函数

1
def hello(name):
2
    def hello1():
3
        print('hello guest!')
4
    def hello2():
5
        print('hello master!')
6
    if name=='White_mu':
7
        return hello2
8
    else:
9
        return hello1
10

11
hellomaster=hello('White_mu')
12
hellomaster()
13
#outputs: hello master!

将函数作为一个参数传给另一个参数#

这个还是好理解，看一下下面的代码就明白了

1
def a():
2
    print('It is a!')
3

4
def b(fun):
5
    print('It is b!')
6
    fun()
7

8
b(a)
9
#outputs: It is b!
10
#outputs: It is a!

一个简单的装饰器#

接下来我们开始来做点有用的装饰器，就以统计函数运行时间为例吧

1
import time
2

3
def count_time(fun):
4
    '''
5
    这是统计函数运行时间的函数
6
    '''
7
    def main():
8
        print('开始统计函数运行时间!')
9
        t1=time.time()
10
        fun()
11
        print('函数运行完毕，运行时间为:',time.time()-t1)
12
    return main
13

14
def waiting():
15
    '''
16
    这是一个普普通通的函数
17
    '''
18
    print('开始运行函数')
19
    print('等待1s...')
20
    time.sleep(1)
21
    print('函数运行结束')
22

23
run_time=count_time(waiting)
24
run_time()

Outputs:

1
开始统计函数运行时间!
2
开始运行函数
3
等待1s...
4
函数运行结束
5
函数运行完毕，运行时间为: 1.00374174118042

@语法糖#

我们将会使用语法糖优化上述代码

1
import time
2

3
def count_time(fun):
4
    '''
5
    这是统计函数运行时间的函数
6
    '''
7
    def main():
8
        print('开始统计函数运行时间!')
9
        t1=time.time()
10
        fun()
11
        print('函数运行完毕，运行时间为:',time.time()-t1)
12
    return main
13

14
@count_time #语法糖：省略了"run_time=count_time(waitting)"和"run_time()"，可直接运行waiting()函数
15
def waiting():
16
    '''
17
    这是一个普普通通的函数
18
    '''
19
    print('开始运行函数')
20
    print('等待1s...')
21
    time.sleep(1)
22
    print('函数运行结束')
23

24
waitting()

装饰器传参#

当我们的函数需要传递参数时，上面的例子可能就不适用了，这时我们可以使用以下方法：

1
import time
2

3
def count_time(fun):
4
    '''
5
    这是统计函数运行时间的函数
6
    '''
7
    def main(*args, **kwargs): #我们需要传入任意参数以达到函数运行的要求
8
        print('开始统计函数运行时间!')
9
        t1=time.time()
10
        fun(*args, **kwargs) #传入刚才传入的函数
11
        print('函数运行完毕，运行时间为:',time.time()-t1)
12
    return main
13

14
@count_time
15
def hellomu(name): #这个函数需要传入name参数
16
    '''
17
    这是一个普普通通的函数
18
    '''
19
    print('开始运行函数')
20
    print('hello! ',name)
21
    print('函数运行结束')
22

23
hellomu('White_mu')

outputs:

1
开始统计函数运行时间!
2
开始运行函数
3
hello!  White_mu
4
函数运行结束
5
函数运行完毕，运行时间为: 0.002000093460083008

这是传入一个参数的例子，接下来我们尝试传入多个参数

1
def count_time(fun):
2
    '''
3
    这是统计函数运行时间的函数
4
    '''
5
    def main(*args, **kwargs): #我们需要传入任意参数以达到函数运行的要求
6
        print('开始统计函数运行时间!')
7
        t1=time.time()
8
        fun(*args, **kwargs) #传入刚才传入的函数
9
        print('函数运行完毕，运行时间为:',time.time()-t1)
10
    return main
11

12
@count_time
13
def hellomu(name,age,high='160cm'): #这个函数需要传入name,age参数，也可以选择传入high参数
14
    '''
15
    这是一个普普通通的函数
16
    '''
17
    print('开始运行函数')
18
    print('hello! ',name)
19
    print('Your age is ',age)
20
    print('You are ',high)
21
    print('函数运行结束')
22

23
hellomu('White_mu','16')

outputs：

1
开始统计函数运行时间!
2
开始运行函数
3
hello!  White_mu
4
Your age is  16
5
You are  160cm
6
函数运行结束
7
函数运行完毕，运行时间为: 0.001997232437133789

带参数的装饰器#

用于在装饰器传入一些备注信息等之类的

1
#这时候我们要用到3层函数
2
def wenhou(msg1='函数准备运行了呐~',msg2='函数运行完毕了呐~'): #第一层：用于传入备注信息
3
    '''
4
    这是一个简简单单的装饰器，用于运行函数时问候您
5
    '''
6
    def wenhou_fun(fun): #第二层：用于传入函数
7
        def main(*args,**kwargs): #第三层：用于装饰器主函数
8
            print(msg1)
9
            fun(*args,**kwargs)
10
            print(msg2)
11
        return main #return2次
12
    return wenhou_fun
13

14
@wenhou(msg1='今天有点感冒，函数快快运行好~') #这时候我们可以传入一些信息到装饰器中，当然，也可以不传
15
def hellomu(name,age,high='160cm'): #这个函数需要传入name,age参数，也可以选择传入high参数
16
    '''
17
    这是一个普普通通的函数
18
    '''
19
    print('开始运行函数')
20
    print('hello! ',name)
21
    print('Your age is ',age)
22
    print('You are ',high)
23
    print('函数运行结束')
24

25
hellomu('White_mu','16')

类装饰器#

上面咱们一起学习了怎么写装饰器函数，在python中，其实也可以同类来实现装饰器的功能，称之为类装饰器。类装饰器的实现是调用了类里面的__call__函数。类装饰器的写法比我们装饰器函数的写法更加简单。

当我们将类作为一个装饰器，工作流程：

通过__init__()方法初始化类通过__call__()方法调用真正的装饰方法

1
class zhuangshiqi:
2
    '''
3
    一个简简单单的装饰器，兼备问候与统计运行时间功能
4
    '''
5
    def __init__(self,msg1='你好master,今天过得怎么样？函数开始运行了哦~',msg2='函数运行完毕了呐~'):
6
        print('正在运行类的__init__函数')
7
        self.msg1=msg1
8
        self.msg2=msg2
9
    def __call__(self,fun): #这里传入函数
10
        print('正在运行类的__call__函数')
11
        def main(*args): #这里传入函数的参数
12
           print('正在运行装饰器main函数')
13
           print(self.msg1)
14
           t1=time.time()
15
           fun(*args)
16
           print('函数运行时间',time.time()-t1)
17
           print(self.msg2)
18
        return main
19

20
@zhuangshiqi(msg1='希望函数能够正常运行~')
21
def hellomu(name,age,high='160cm'): #这个函数需要传入name,age参数，也可以选择传入high参数
22
    '''
23
    这是一个普普通通的函数
24
    '''
25
    print('开始运行函数')
26
    print('hello! ',name)
27
    print('Your age is ',age)
28
    print('You are ',high)
29
    print('函数运行结束')
30

31

32
if __name__=='__main__':
33
    hellomu('White_mu','16')

outputs:

1
正在运行类的__init__函数
2
正在运行类的__call__函数
3
正在运行装饰器main函数
4
希望函数能够正常运行~
5
开始运行函数
6
hello!  White_mu
7
Your age is  16
8
You are  160cm
9
函数运行结束
10
函数运行时间 0.0019986629486083984
11
函数运行完毕了呐~