python高级-闭包-装饰器
2021-05-04 13:29
标签：错误 list containe test UNC demo 嵌套 lis 形式 匿名函数：能够完成简单的功能，传递这个函数的引用，只有功能 普通函数：能够完成复杂的功能，传递这个函数的引用，只有功能 闭包：能够完成较为复杂的功能，传递这个闭包中的函数以及数据，因此传递是功能+数据 对象：能够完成最复杂的功能，传递很多数据+很多功能，因此传递的是数据+功能 ——————————————————— 对全局函数进行修改：在函数当中加global，在闭包中外边中的变量加nonlocal 闭包定义：有两个函数嵌套使用，里面的函数可以使用外面函数所传输的参数，最后可传递的是里面函数的结构与数据(个人理解)。 最后闭包可以在python中引申出装饰器 ——————————————————— 代码要遵守‘开放封闭’原则；对已经写好的函数遵守封闭，对功能扩展遵守开放； 使用装饰器来测试一个函数的运行时: 复现装饰器原理： ————————————————————————- 注意： 首先执行第一个，但是第一个装饰器下面不是函数（装饰器原则：下面必须是函数，否则不执行），所以第一个函数先等待，等第二个装饰器执行后形成函数在交给第一个装饰器；所以运行结果是： 开始进行装饰xx的功能， 开始进行装饰权限1， 这是权限验证1， 这是xx权限验证， ——- ——————装饰器练习—————- 输出格式： python高级-闭包-装饰器 标签：错误 list containe test UNC demo 嵌套 lis 形式 原文地址：https://www.cnblogs.com/xbhog/p/13194954.html闭包内容：
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 ?
test1——-，haha
1 def set_func_1(func):
2 def call_func():
3 return ‘
’ + func() + ’
’
4 return call_func
5
6 ?
7 def set_func_2(func):
8 def call_func():
9 return ‘’ + func() + ’ ’
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 最后执行的效果： haha 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())
以上就是装饰器与闭包的全部内容，希望有所收获，如果有错误，希望指出，感谢！！