［Python进阶］Python闭包的深入浅出

前提准备

首先我们要明白在python中一切皆对象，数字、字符串、元组、列表、字典、函数、方法、类、模块等等都是对象。

因为函数也是一个对象，所以函数能够像其他变量一样被当作参数传给其他的函数，同样函数能也能够作为另一个函数的结果返回
map、sorted,filter 这几个函数都可以接受一个函数作为参数，具体用法就不在此赘述了
 自由变量：指未在本地作用域绑定的变量，是相对来说的
建议看一下这个文章自由变量函数闭包

闭包产生的原因：出现了函数嵌套，且内层函数使用了不是自己作用域的变量

一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

闭包简而言之就是将数据和内部函数封装到一个包(区域)中
函数的闭包就是一种函数嵌套的一种特殊情况

闭包的使用方式

 在讲解闭包之前我们先看一些例子，希望大家带着疑问去学习，去理解后面的讲解
 

• 方式一：将某些变量定义在函数内部，不与全局的变量发生冲突
  

1. def outer():
2.     name = "fish"  
3.     def inner():  # 子函数可以有很多个
4.         print(name)
5.     return inner
6. f1 = outer()
7. f1() # fish

复制代码

我们可以看到，虽然name = "fish" 是局部的变量，但是在外部调用f1()的时候仍然可以正常的使用

 

• 方式二：将外部数据封装到函数内部（重点)
  

1. def outer(name):
2.     def inner():
3.         print(name)
4.     return inner   # 将内部的函数返回出去
5. name = 'fish'
6. f1 = outer(name)
7. name = 'tom'
8. f2 = outer(name)
9. f1()  # 输出 fish
10. f2()  # 输出 tom

复制代码

错误理解：在调用函数f1,f2时因为内部没有定义name变量，所以函数执行时会去全局变量中找，此时全局变量name=tom结果应该都会输出 tom
但是实际输出f1()输出fish，f2()输出tom

1. [/code][indent]我们能够发现在调用f1()，f2()使用的变量并没有随着全局变量的变化而改变，仍然是创建f1()，f2()函数对象时的内容
2.  [/indent][size=5]闭包的理论讲解[/size]
4.  下面我们一步步的解释这个原因，由表及里的解释
5.  每执行一遍fn = outer(x) 就会生成一个函数对象，每一个函数对象都有自己的内存空间，也会被存储到这个内存空间，这个过程就叫闭包，这个变量叫做自由变量后面再使用变量的时候就会从这个内存空间里面取值[img]https://img2022.cnblogs.com/blog/3006005/202210/3006005-20221018134500332-1261897062.png[/img] 
6.  
7. [indent]注:这个图不是实际的内存结构图，只是为了便于讲解
8. [/indent][indent]现在是不是有个疑问，怎么就闭包了？自由变量到底存到了哪里？
9. [/indent]下面我们就根据源码来探究这个问题
10.  在回忆一下文章开头说的那句话python中一切皆对象，函数也是对象，是对象就有属性，我们现在就有理由怀疑自由变量被存到了函数对象的属性中。
11.  事实上自由变量就是存到了函数对象的属性中,我先说明出来，后面会有代码的验证
12. 当执行执行outer函数结束时，如果内部函数inner中如果将来会使用自由变量，那么内部函数inner的__closure__ 属性就会保存需要的自由变量,该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用，又因为f1和f2不是同一个函数对象，所以函数对象的__closure__ 属性保存的数据也不同。
15. [size=5]闭包的代码验证[/size]
17.  下面让我们用代码验证
18.  
19. [list]
20. [*]内部函数没有使用自由变量，此时它的__closure__属性为None
21. [/list][code]def outer():
22.     def inner():
23.         print('hello')
24.     return inner
25. f = outer()
26. print(f.__closure__) # None

复制代码

• 内部函数使用自由变量,此时它的__closure__属性是一个元组里面存储自由变量
  

1. def outer():
2.     name = 'fish'
3.     age = 112
4.     def inner():
5.         print(name,age)
6.     return inner
7. f = outer()
8. print(f.__closure__)
9. # (<cell at 0x000001ED4A6BAFD0: int object at 0x000001ED30E85750>, <cell at 0x000001ED4A6BAFA0: str object at 0x000001ED30FF74F0>)

复制代码

内部函数没有使用自由变量：函数对象的__closure__属性没有值，
内部函数使用自由变量： 函数对象的__closure__属性是一个元组，里面存着自由变量的地址，__closure__属性可以存储多个自由变量的内容
 
最终我们回到一开始的三个例子中，验证__closure__属性是不是闭包中数据存放的位置

1. # 依旧是实例中的函数
2. def outer(name):
3.     def inner():
4.         print(name)
5.     return inner   # 将内部的函数返回出去
6. name = 'fish'
7. f1 = outer(name)
8. name = 'tom'
9. f2 = outer(name)
10. # 解释一下代码的含义
11. # 取出__closure__[0]中的第一个元素，返回的是一个cell单元格对象
12. # .cell_contents 获取cell单元格对象具体的值
13. print(f1.__closure__) #(<cell at 0x000001615108AA90: str object at 0x00000161379E4B70>,)
14. print(f1.__closure__[0].cell_contents)  # fish
15. print(f2.__closure__[0].cell_contents)  # tom
16. f1()  # 输出 fish
17. f2()  # 输出 tom

复制代码

通过我们的实际操作以及输出，我们发现__closure__属性保存的内容就是创建函数对象时的自由变量
 经过理论加代码验证相信你已经能够理解Python的闭包的真正情况，我们可以很明显的认识到原来闭包也没有这么神秘，
 最后我们总结一下函数的闭包
 闭包就是嵌套函数的一种特殊情况，内层函数需要使用自由变量，这个变量不会随着外层函数的结束而被销毁，它会被保存到函数对象的__closure__属性中。
 闭包的实战

 

• 装饰器
  Python中大名鼎鼎的装饰器的实现就有闭包的思想，关于这个装饰器，这里就不具体阐述，过两天我会更新一个关于装饰器的博客
  

• 多线程爬虫
  暂时看不懂也没有关系
  

1. from concurrent.futures.thread import ThreadPoolExecutor
2. import requests
4. def download(url):
5.     header = {
6.         "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36"
7.     }
8.     res = requests.get(url=url,headers=header)
9.     return res.text
10. def outer(file_name):
11.     def write_file(response):
12.         # print(type(response.result()))
13.         content = response.result()
14.         print(file_name)
15.         with open(file_name,'w',encoding='utf8') as fp:
16.             fp.write(content)
17.     return write_file
19. Pool = ThreadPoolExecutor(5)
21. url_arr = [
22.     ("https://www.163.com/news/article/HJQC8KGG000189FH.html",'1.txt'),
23.     ("https://www.163.com/news/article/HJQCBM89000189FH.html",'2.txt'),
24.     ("https://www.163.com/news/article/HJPTU9E8000189FH.html",'3.txt'),
25.     ("https://www.163.com/news/article/HJQ64VA1000189FH.html",'4.txt'),
26.     ("https://www.163.com/news/article/HJQ0V8VJ000189FH.html",'5.txt')
27. ]
29. for item in url_arr:
30.     future = Pool.submit(download,item[0])  # 通过submit提交执行的函数到线程池中
31.     future.add_done_callback(outer(item[1]))
32. Pool.shutdown()

复制代码

 
总结

 通过这篇文章希望大家能够明白什么是Python的闭包,通过代码验证我们可以闭包并不神秘，只是函数对象的一个属性保存了自由变量。
Python的闭包独自使用的情况很少，通常都是和其他的应用一块使用，但是闭包这个思想很重要，面试经常问到。

1. <br><br><br><br>

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！