python高级-闭包-装饰器

Posted xbhog

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python高级-闭包-装饰器相关的知识,希望对你有一定的参考价值。

闭包内容:

  1. 匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能

  2. 普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能

  3. 闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递是功能+数据

  4. 对象:能够完成最复杂的功能,传递很多数据+很多功能,因此传递的是数据+功能

———————————————————

  1. 对全局函数进行修改:在函数当中加global,在闭包中外边中的变量加nonlocal

  2. 闭包定义:有两个函数嵌套使用,里面的函数可以使用外面函数所传输的参数,最后可传递的是里面函数的结构与数据(个人理解)。

  3. 最后闭包可以在python中引申出装饰器 ———————————————————

 1 def closure():
 2     # 在函数内部再定义一个函数,
 3     # 并且这个函数用到了外边函数的变量,那么将这个函数以及用到的一些变量称之为闭包
 4     def closure_in(x):
 5         print(---------我是打不死的%s-------- %x)
 6     return closure_in
 7 ?
 8 x = closure()
 9 x(小强)
10 ?
11 print(**20)
12 # -----加餐---------
13 def closure_1(a,b,c):
14     def closure_on(x):
15         print(-----%s加餐------- %b)
16         print(a*x + c)
17     return closure_on
18 ?
19 demo = closure_1(2,小强,3) #传closure_1函数
20 demo(4) #传clsure_on函数
21 ?
22 #注:函数不加括号,调用的是函数本身【function】;函数加括号,调用的是函数的return结果。

 

装饰器内容:

代码要遵守‘开放封闭’原则;对已经写好的函数遵守封闭,对功能扩展遵守开放;

 1 # 装饰器的作用:为了对原来的代码上进行扩展
 2 def decoration(func):
 3     def call_func():
 4         print(-------正在装饰 ------- )
 5         func()
 6     return call_func
 7 ?
 8 #@decoration     #--->demo_new = decoration(demo)
 9 def demo():
10    print(demo----)
11 ?
12 demo_new = decoration(demo)
13 demo_new()

 

使用装饰器来测试一个函数的运行时:

 1 import time
 2 def set_func(func):
 3     def call_func():
 4         start_time = time.time()
 5         func()
 6         stop_func = time.time()
 7         print(‘alltimes is %f’ %(stop_func-start_fun))
 8     return call_func
 9 @set_func
10 def test1():
11     print(‘——-test1———’)    
12 test1()
13 ?
14 #等价于:
15 @set_func==test1 = set_func(test1)
16 ?

 

1. 没有参数,没有返回值的函数进行装饰:
 1 def set_func(func):
 2     def call_func():
 3         print(‘———test2——-’)
 4         print(‘———-test3——’)
 5         func()
 6     return call_func
 7     
 8 @set_func
 9 def test1():
10     print(‘——test1——-   ’)

 

2. 对有参数无返回值的函数进行装饰:
 1 def set_func(func):
 2     def call_func(a):  #
 3         print(‘———test2——-’)
 4         print(‘———-test3——’)
 5         func(a) #
 6     return call_func
 7     
 8 @set_func
 9 def test1(num):
10     print(‘——test1——- %d    ’ %num)
11 ?
12 test1(100) —->call_func(100)
13 test1(200)——>call_func(200)

 

复现装饰器原理:

————————————————————————-

只要遇到@函数 装饰器(这句话),在程序中就已经执行了!!
3. 不定长参数的函数装饰:
 1 def set_func(func):
 2     def call_func(*args,**kwargs):  #
 3         print(‘———test2——-’)
 4         print(‘———-test3——’)
 5         func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;
 6         #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
 7     return call_func
 8     
 9 @set_func
10 def test1(num,*args,**kwargs):
11     print(‘——test1——- %d    ’ %num)
12     print(‘——test1——-   ’ , args)
13     print(‘——test1——- ’ ,kwargs )
14     
15 test1(100)  
16 test1(100,200)
17 test1(100,200,300,mm=100)

注意:*args保存不定长参数,以元祖保存,**kwargs保存字典形式(mm=...)

4.对应的返回值参数进行装饰、通用装饰器:
 1 #通用装饰器
 2 def set_func(func):
 3     print(“开始进行装饰———-”)
 4     def call_func(*args,**kwargs):  #
 5         print(‘———test2——-’)
 6         print(‘———-test3——’)
 7         return func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;如果没有return ret返回none。
 8         #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
 9     return call_func
10     
11 @set_func
12 def test1(num,*args,**kwargs):
13     print(‘——test1——- %d    ’ %num)
14     print(‘——test1——-   ’ , args)
15     print(‘——test1——- ’ ,kwargs )
16     return ‘ok’    #—-返回给上面的func(),然后return func—ret
17     
18 ret = test1(100)
19 ?

 

5. 多个装饰器对同一个函数进行装饰:
 1 def add_qx(func):
 2     print(“——开始进行装饰权限1———-”)
 3     def call_func(*args,**kwargs):  #
 4         print(‘这是权限验证1’)
 5         return func(*args,**kwargs)
 6     return call_func
 7     
 8 ?
 9 def add_xx(func):
10     print(“——开始进行装饰xx功能———-”)
11     def call_func(*args,**kwargs):  #
12         print(‘这是xx权限验证’)
13         return func(*args,**kwargs)
14     return call_func
15     
16 @add_qx
17 @add_xx
18 def test1():
19     print(‘——test1——-’) 
20 ?
21 test1()
22 ?

 

首先执行第一个,但是第一个装饰器下面不是函数(装饰器原则:下面必须是函数,否则不执行),所以第一个函数先等待,等第二个装饰器执行后形成函数在交给第一个装饰器;所以运行结果是:

  1. 开始进行装饰xx的功能,

  2. 开始进行装饰权限1,

  3. 这是权限验证1,

  4. 这是xx权限验证,

  5. ——-test1——-,

——————装饰器练习—————- 输出格式:<td><h1>haha</h1></td>

 1 def set_func_1(func):
 2     def call_func():
 3         return ‘<h1>’ + func() + ’</h1> 4     return call_func
 5     
 6 ?
 7 def set_func_2(func):
 8     def call_func():
 9         return ‘<td>’ + func() + ’</td>10     return call_func
11     
12 @set_func_1()
13 @set_func_2()
14 def get_str():
15     return ‘haha’
16     
17 print(get_str()) 

18 最后执行的效果: <h1><td>haha</td></h1>
6. 用类对函数进行装饰(了解):
 1 class Test(object):
 2     def __init__(self,func):
 3         self.func = fun
 4         
 5     def __call__(self):
 6         print(‘这里是装饰器的功能。。。。’)
 7         return self.func()
 8         
 9 @Test
10 def get_str():
11     return ‘haha’
12     
13 print(get_str())

 

以上就是装饰器与闭包的全部内容,希望有所收获,如果有错误,希望指出,感谢!!

 

以上是关于python高级-闭包-装饰器的主要内容,如果未能解决你的问题,请参考以下文章

浅谈Python装饰器

Python 简明教程 --- 22,Python 闭包与装饰器

32.Python面向对象描述符运算符底层装饰器:闭包-闭包参数-内置装饰器-类装饰器

32.Python面向对象描述符运算符底层装饰器:闭包-闭包参数-内置装饰器-类装饰器

32.Python面向对象描述符运算符底层装饰器:闭包-闭包参数-内置装饰器-类装饰器

Python函数进阶:闭包装饰器生成器协程