python 闭包

什么是闭包

 1 #定义一个函数
 2 def test(number):
 3 
 4     #在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
 5     def test_in(number_in):
 6         print("in test_in 函数, number_in is %d"%number_in)
 7         return number+number_in
 8     #其实这里返回的就是闭包的结果
 9     return test_in
10 
11 
12 #给test函数赋值，这个20就是给参数number
13 ret = test(20)
14 
15 #注意这里的100其实给参数number_in
16 print(ret(100))
17 
18 #注意这里的200其实给参数number_in
19 print(ret(200))

运行结果

in test_in 函数, number_in is 100

120

 

in test_in 函数, number_in is 200

220

内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。

1 def func():
2     name = 'gg'
3     def inner():
4         print(name)
5     return inner
6 
7 f = func()
8 f()

nonlocal访问外部函数的局部变量(python3) ****上一层局部变量，就近原则****

 1 def counter(start=0):
 2     def incr():
 3         nonlocal start
 4         start += 1
 5         return start
 6     return incr
 7 
 8 c1 = counter(5)
 9 print(c1())
10 print(c1())
11 
12 c2 = counter(50)
13 print(c2())
14 print(c2())
15 
16 print(c1())
17 print(c1())
18 
19 print(c2())
20 print(c2())

 

判断闭包函数的方法__closure__

 1 #输出的__closure__有cell元素 ：是闭包函数
 2 def func():
 3     name = 'eva'
 4     def inner():
 5         print(name)
 6     print(inner.__closure__)
 7     return inner
 8 
 9 f = func()
10 f()
11 
12 #输出的__closure__为None ：不是闭包函数
13 name = 'egon'
14 def func2():
15     def inner():
16         print(name)
17     print(inner.__closure__)
18     return inner
19 
20 f2 = func2()
21 f2()

 思考：

1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

装饰器的前世今生

   本人上班也有一段日子，终于到了发年终奖的时候，但年终奖评比的标准是一个问题，于是有人提议就用每个函数的执行时间来评比年终奖吧

作为团队的小家伙，审核的工作便落在了小掌门身上

通常开发部门的代码是这样的

1 2	def func():     print("老板好")

本人灵机一动

1 2 3 4 5 6 7 8

import time def func():     start=time.time()     print("老板好")     time.sleep(0.1)#假设为执行时间，实际代码肯定不是一个print能搞定的     print(time.ctime()-start)       func()

不知不觉，一个礼拜过去了，本人前前后后改了四五千个函数

这可没法忍，老夫做的可是技术，怎么搞得跟苦力一样，得像个办法让自己轻松点，本人写了个timer函数，于是又一个代码版本应运而生

本跟所有开发同事讲，你们的审核已经搞定了，你们每个在自己代码中加一句调用时间的函数吧

1 import time
2 def func():
3     print("老板好")
4     time.sleep(0.1)#假设为执行时间，实际代码肯定不是一个print能搞定的
5 
6 start=time.time()
7 func()
8 print(time.ctime()-start)

就这样过了几天，所有的同事见了本人都一脸怨气，老大看本人的眼神也是充满邪恶。本人感到了恐慌，又把之前写的代码拿出来完善了下

于是有了下个版本

1 import time
2 def func():
3     print("老板好")
4     time.sleep(0.1)#假设为执行时间，实际代码肯定不是一个print能搞定的
5 
6 def timer(func):
7     start=time.time()
8     func()
9     print(time.ctime()-start)

本人告诉的大家，实际用的时候，自己调用timer就行了，看起来有些不错，但还有些瑕疵 ，有人提示我说可以使用语法糖，接着又一版本出现

 1 import time
 2 def timer(func):
 3     def inner():
 4         start = time.time()
 5         func()
 6         print(time.time() - start)
 7     return inner
 8 @timer
 9 def func():
10     print("老板好")
11     time.sleep(0.1)#假设为执行时间，实际代码肯定不是一个print能搞定的
12 
13 func()

在需要计算时间的函数前加一句@timer就行了

我想，同事的参数可能带参数，也有可能带返回值啊，上面的代码似乎搞定不了，后来，我潜心研究语法糖，于是就有了最终的版本

 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         ret=func()
 6         print(time.time() - start)
 7         return  ret
 8     return inner
 9 @timer
10 def func():
11     print("老板好")
12     time.sleep(0.1)#假设为执行时间，实际代码肯定不是一个print能搞定的
13 
14 func()

 

 

练习：

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

默写任务： 1.需默写代码&执行过程&使用方法 def timer(func):     def inner(*args,**kwargs):         '''执行函数之前要做的'''         re = func(*args,**kwargs)         '''执行函数之后要做的'''         return re     return inner   @timer def aaa():print(‘a’)   2.默写代码 import time def timer(func):     def inner(*args,**kwargs):         start = time.time()         ret = func(*args,**kwargs)         print(time.time() - start)         return ret     return inner   @timer   #==> func = timer(func) def func(a):     print('你好我好大家好')     return '新年好'