函数-装饰器

一、简单的装饰器

1.为什么要使用装饰器呢?

装饰器的功能:在不修改原函数及其调用方式的情况下对原函数功能进行扩展

装饰器的本质:就是一个闭包函数

那么我们先来看一个简单的装饰器:实现计算每个函数的执行时间的功能

 1 import time 
 2 def  wrapper(func):
 3         def inner():
 4               start=time.time()
 5               func()
 6               end=time.time()
 7               print(end-start)
 8         return inner 
 9     
10 def  hahaha():
11         time.sleep(1)
12         print('aaaaa')
13 hahaha=wrapper(hahaha)
14 hahaha()    
简单的装饰器

上面的功能有点不简介,不完美,下面就引进了语法糖。

 1 import time
 2 def wrapper(func):
 3         def inner():
 4                start=time.time()
 5                func()
 6                end=time.time()
 7                print(end-start)
 8         return inner
 9 @wrapper
10 def  kkk():#相当于kkk=wrapper(kkk)
11     print('aaaaa')
12 kkk()             
装饰器-------语法糖

以上的装饰器都是不带参数的函数,现在装饰一个带参数的该怎么办呢?

 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end- start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def func1(a,b):
13     print('in func1')
14     print(a,b)
15 
16 @timer   #==> func1 = timer(func1)
17 def func2(a):
18     print('in func2 and get a:%s'%(a))
19     return 'fun2 over'
20 
21 func1(1,2)
22 print(func2('aaaaaa'))
原函数带多个参数的装饰器
 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end - start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def jjj(a):
13     print('in jjj and get a:%s'%(a))
14     return 'fun2 over'
15 
16 jjj('aaaaaa')
17 print(jjj('aaaaaa'))
带返回值的装饰器

二、开放封闭原则

对扩展是开放的

对修改是封闭的

三、装饰器的固定结构

import time
def wrapper(func):  # 装饰器
    def inner(*args, **kwargs):
        '''函数执行之前的内容扩展'''
        ret = func(*args, **kwargs)
         '''函数执行之前的内容扩展'''
        return ret
    return inner

@wrapper  # =====>aaa=timmer(aaa)
def aaa():
    time.sleep(1)
    print('fdfgdg')
aaa()

四、带参数的装饰器

带参数的装饰器:就是给装饰器传参

用处:就是当加了很多装饰器的时候,现在忽然又不想加装饰器了,想把装饰器给去掉了,但是那么多的代码,一个一个的去闲的麻烦,那么,我们可以利用带参数的装饰器去装饰它,这就他就像一个开关一样,要的时候就调用了,不用的时候就去掉了。给装饰器里面传个参数,那么那个语法糖也要带个括号。在语法糖的括号内传参。在这里,我们可以用三层嵌套,弄一个标识为去标识。如下面的代码示例

 1 # 带参数的装饰器:(相当于开关)为了给装饰器传参
 2 # F=True#为True时就把装饰器给加上了
 3 F=False#为False时就把装饰器给去掉了
 4 def outer(flag):
 5     def wrapper(func):
 6         def inner(*args,**kwargs):
 7             if flag:
 8                 print('before')
 9                 ret=func(*args,**kwargs)
10                 print('after')
11             else:
12                 ret = func(*args, **kwargs)
13             return ret
14         return inner
15     return wrapper
16 
17 @outer(F)#@wrapper
18 def hahaha():
19     print('hahaha')
20 
21 @outer(F)
22 def shuangwaiwai():
23     print('shuangwaiwai')
24 
25 hahaha()
26 shuangwaiwai()
给装饰器加参数

五、多个装饰器装饰一个函数

 1 def qqqxing(fun):
 2     def inner(*args,**kwargs):
 3         print('in qqxing: before')
 4         ret = fun(*args,**kwargs)
 5         print('in qqxing: after')
 6         return ret
 7     return inner
 8 
 9 def pipixia(fun):
10     def inner(*args,**kwargs):
11         print('in qqxing: before')
12         ret = fun(*args,**kwargs)
13         print('in qqxing: after')
14         return ret
15     return inner
16 @qqqxing
17 @pipixia
18 def dapangxie():
19     print('饿了吗')
20 dapangxie()
21 
22 '''
23 @qqqxing和@pipixia的执行顺序:先执行qqqxing里面的 print('in qqxing: before'),然后跳到了pipixia里面的
24         print('in qqxing: before')
25         ret = fun(*args,**kwargs)
26         print('in qqxing: after'),完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的运行结果截图一样
27 '''
多个装饰器装饰一个函数

上例代码的运行结果截图

posted @ 2017-07-28 19:14  East~L  阅读(211)  评论(0编辑  收藏  举报