闭包内容：

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_on18 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_func10 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_func10 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_func10     11 @set_func12 def test1(num,*args,**kwargs):13     print(‘——test1——- %d    ’ %num)14     print(‘——test1——-   ’ , args)15     print(‘——test1——- ’ ,kwargs )16     return ‘ok’    #—-返回给上面的func()，然后return func—ret17     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_func15     16 @add_qx17 @add_xx18 def test1():19     print(‘——test1——-’) 
20 21 test1()22

 

首先执行第一个，但是第一个装饰器下面不是函数（装饰器原则：下面必须是函数，否则不执行），所以第一个函数先等待，等第二个装饰器执行后形成函数在交给第一个装饰器；所以运行结果是：

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

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

3. 这是权限验证1，

4. 这是xx权限验证，

5. ——-test1——-，

——————装饰器练习—————- 输出格式：

haha

 1 def set_func_1(func): 2     def call_func(): 3         return ‘’ 4     return call_func 5      6  7 def set_func_2(func): 8     def call_func(): 9         return ‘’10     return call_func11     12@set_func_1()13@set_func_2()14def get_str():15     return ‘haha’16     17print(get_str()) 

18 最后执行的效果：

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 @Test10 def get_str():11     return ‘haha’12     13 print(get_str())

 

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