Python 闭包坑点

最新推荐文章于 2023-07-25 15:39:30 发布
转载 最新推荐文章于 2023-07-25 15:39:30 发布 · 313 阅读 · 0

640

闭包坑点

上篇参考：Python 闭包使用注意点，接下来，介绍使用闭包，经常会犯的一个错误：演示代码如下，


 
  1. In [6]: def boy(pos): 
  2.  ...: def run(step): 
  3.  ...: pos = pos + step 
  4.  ...: return pos 
  5.  ...: return run 
  6.  ...: 

  8. In [7]: r = boy(0) 

  10. In [9]: r(10) 
  11. ---------------------------------------------------------------------------
  12. UnboundLocalError Traceback (most recent call last)
  13. <ipython-input-9-5a4ba556b403> in <module>
  14. ----> 1 r(10)

  16. <ipython-input-6-9b6d05d20cb3> in run(step)
  17.  1 def boy(pos):
  18.  2 def run(step):
  19. ----> 3 pos = pos + step
  20.  4 return pos
  21.  5 return run

  23. UnboundLocalError: local variable 'pos' referenced before assignment

 


 


 640
 
分析原因

 
python 规则指定所有在赋值语句左面的变量都是局部变量，则在闭包 run() 中，变量 pos 在赋值符号"="的左面，被 python 认为是 run() 中的局部变量。

 


 
再接下来执行 r() 时，程序运行至 pos = pos + step 时，因为先前已经把 pos 归为 run() 中的局部变量，所以 python 会在 run() 中去找在赋值语句右面的 pos 的值，结果找不到，就会报错。

 


 


 640
 
解决措施

 
在 python3 以后，在 pos = pos + 1 之前，使用语句 nonloacal pos 显式的指定 pos 不是闭包的局部变量。

 

 
  1. In [14]: def boy(pos): 
  2.  ...: def run(step): 
  3.  ...: nonlocal pos 
  4.  ...: pos = pos + step 
  5.  ...: return pos 
  6.  ...: return run 
  7.   

  9. In [15]: r = boy(0) 

  11. In [16]: r(10) 
  12. Out[16]: 10

 


 
我们可以利用，闭包执行完后仍然能够保持住当前的运行环境。

 
演示代码如下：

 


 

 
  1. In [14]: def boy(pos): 
  2.  ...: def run(step): 
  3.  ...: nonlocal pos 
  4.  ...: pos = pos + step 
  5.  ...: return pos 
  6.  ...: return run  

  8. In [15]: run = boy(0) 

  10. In [16]: run(10) 
  11. Out[16]: 10

  13. In [17]: run(20) 
  14. Out[17]: 30

  16. In [18]: run(10) 
  17. Out[18]: 40

 
可以看出，返回的闭包 run 中保存了 pos的值，下次执行闭包会记住上次 pos 的值，这就是闭包的数据持久化功能。文章参考：https://www.cnblogs.com/JohnABC/p/4076855.html

 


 


 

 
更多文章，点击图片

 


 
640?wx_fmt=png

 


 
640?wx_fmt=png

 


 
640?wx_fmt=jpeg

 
长按订阅

 


 
smiley_66.png点个好看
 


                

        

    

    
  



    

      

        

            

              
                
                  算法channel
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
Python3 【闭包】避坑指南：常见错误解析

				
			

			

				

					ROGERLEE- Python场景式编程学习与训练
				

				

					02-01
					
					476
					
				

			

		

		

			
				
闭包常见错误分析

			
		

	



                

            
              



	

		

			

				
					
Python转JS代码迁移避坑指南：详解语法差异与常见陷阱

					
最新发布

				
			

			

				

					IT深耕十余载，大道之简
				

				

					07-01
					
					876
					
				

			

		

		

			
				
Python转JS核心痛点与解决方案 在Python转JS的代码迁移中，开发者常面临三大挑战： 语法差异：变量作用域、类型系统、this绑定等存在根本性差异 异步编程：协程与Promise的机制不同，事件循环处理方式迥异 面向对象：继承机制和类构造函数的实现逻辑差异 典型陷阱包括： 块级作用域误用导致变量泄露 隐式类型转换引发逻辑错误 this动态绑定造成方法调用异常 解决方案： 使用ES6+特性（let/const、箭头函数） 严格类型检查（===操作符） 防御性编程（可选链、空值合并） 构建跨语言测试套

			
		

	



              


  
              

                


	

		

			

				
					
Python闭包的坑

				
			

			

				

					weixin_34082376的博客
				

				

					05-25
					
					436
					
				

			

		

		

			
				
闭包（closure)
当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当内部函数被当做返回值的时候，相关参数和变量保存在返回的函数中，这种结果，叫闭包
# 闭包常见坑
def count():
    # 定义列表，列表里存放的是定义的函数
    fs = []
    for i in range(1,4):
        # 定义了一个函数f
        # ...

			
		

	





	

		

			

				
					
Python的坑（8） -- 闭包

				
			

			

				

					Henry1991back的博客
				

				

					07-08
					
					548
					
				

			

		

		

			
				
1.Vamei：

Python深入04 闭包

http://www.cnblogs.com/vamei/archive/2012/12/15/2772451.html

“由此，我们可以看到，闭包也具有提高代码可复用性的作用。

如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函

			
		

	



		

			
		



	

		

			

				
					
Python进阶(四)浅谈Python闭包

					
热门推荐

				
			

			

				

					IT全栈 华强工作室
				

				

					03-15
					
					4万+
					
				

			

		

		

			
				
注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

			
		

	





	

		

			

				
					
python 闭包_Python 闭包坑点

				
			

			

				

					weixin_39924329的博客
				

				

					12-07
					
					158
					
				

			

		

		

			
				
闭包坑点上篇参考：Python 闭包使用注意点，接下来，介绍使用闭包，经常会犯的一个错误：演示代码如下，In [6]: def boy(pos):    ...:     def run(step):    ...:         pos = pos + step    ...:         return pos    ...:     return run    ...:    ...

			
		

	





	

		

			

				
					
python 闭包，你必须知道的坑！

				
			

			

				

					qq_20831785的博客
				

				

					06-21
					
					402
					
				

			

		

		

			
				
funcs = []
result_list = []
for x in range(3):
    def do_some():
        return x
    funcs.append(do_some)
    result_list.append(do_some())  # 注意这里函数被执行了

funcs_result_list = [func() for func in funcs]

很多人以为result_list和funcs_result_list的结果是一样的，都是[0, 1,

			
		

	





	

		

			

				
					
Python closure闭包解释及其注意点详解

				
			

			

				

					01-01
				

			

		

		

			
				
3.闭包常见的坑  def count():  #定义列表 fs = [] for i in range(1, 4):  def f():  return i * i fs.append(f) # 按照我们的预期， 应该是fs = [f, f, f].其中f中一次包含1， 4， 9， 这样才对， 但实际结果不是...

			
		

	





	

		

			

				
					
【JavaScript源代码】浅谈react useEffect闭包的坑.docx

				
			

			

				

					12-30
				

			

		

		

			
				
### React中的useEffect与闭包问题详解  #### 一、问题背景  在React开发中，`useEffect`是一个非常强大的Hook，它可以帮助我们处理副作用逻辑，例如数据获取、订阅或者手动更改DOM等。然而，使用不当可能会导致一些...

			
		

	





	

		

			

				
					
Python学习笔记：一周挑战与坑点解析

				
			

			

				

					
				

			

		

		

			
				
为了解决这个问题，可以使用`lambda`函数来创建闭包，确保`x`的作用域正确。  2. 装饰器是一种强大的工具，可以用来修改或增强函数或类的行为。这里提到了类装饰器在方法上的应用问题。在Python中，类装饰器需要特殊...

			
		

	





	

		

			

				
					
详解Python闭包及其中隐藏的陷阱。

				
			

			

				

					python学习者的博客
				

				

					03-22
					
					1332
					
				

			

		

		

			
				
什么是闭包？

其实我们在使用函数过程中不经意间就会触发闭包，因为总会出于某种原因会在一个函数内部再定义一个函数，而当内层函数引用了外层函数命名空间内的变量（或者说对象），这时就会触发闭包。

那么什么是闭包？闭包就是对内层函数和其内部引用的上层局部命名空间变量的一种封装。

我们说触发了闭包规则的函数叫做闭包函数

闭包的应用方法：通过外层函数把闭包函数对象（python一切皆对象，函数也是对象...

			
		

	





	

		

			

				
					
闭包的一个坑

				
			

			

				

					博客不一定要自己做
				

				

					03-17
					
					352
					
				

			

		

		

			
				
for (var i = 0; i < 5; i++) { 
  setTimeout(function () { 
    console.log(i); 
  }, 5); 
} 
上面这个代码块会打印五个 5 出来，而我们预想的结果是打印 0 1 2 3 4。之所以会这样，是因为 setTimeout 中的 i 是对外层 i 的引用。当 setTimeout 的代码被解释的时候，运行时只是记录

			
		

	





	

		

			

				
					
python 多线程笔记（6）-- 闭包

				
			

			

				

					derek881122的博客
				

				

					02-03
					
					238
					
				

			

		

		

			
				
在类里弄一个闭包出来

很多资料上说，类内部的变量有两种。
按定义所在的位置，分__init__上方的和__init__下方的
按内存所在的位置，分类的和实例的，或者说公共的和私有的

现在，我想在类里定义一个保存实例个数的变量 x，如下：

>>> class Foo:
. . .   x = 0
. . .   def __init__(se...

			
		

	





	

		

			

				
					
python函数式编程——闭包

				
			

			

				

					正心全栈编程
				

				

					05-01
					
					229
					
				

			

		

		

			
				
# 非闭包
def curve_pre():
    def curve():
        print('This is a function') 
    return curve
f = curve_pre()
f()# 闭包 = 函数 + 环境变量
# 现场
def curve_pre():
    a = 25
    def curve(x):
        return a*x*...

			
		

	





	

		

			

				
					
python中函数闭包

				
			

			

				

					初入python踩过的坑
				

				

					08-01
					
					225
					
				

			

		

		

			
				
闭包：一个函数嵌套另一个函数，外面的函数简称为外函数，里面的为内函数，外函数返回内函数。与普通函数不同的是，普通函数调用完后，函数中的局部变量消失，返回内存，而闭包外函数调用后，外函数的局部变量没有消失，而是继续留给内函数使用。
1，普通函数
def fn():
	a = 2
	return a
fn()
print(a)
#输出报错name 'a' is not defined

因为a是局部变...

			
		

	





	

		

			

				
					
Python闭包与闭包陷阱

				
			

			

				

					Hello Word
				

				

					01-25
					
					1887
					
				

			

		

		

			
				
Python中的闭包陷阱指的是在闭包中引用了变量时，如果该变量在闭包外部被修改，则闭包内部的值也会改变。这可能会导致程序的错误或意外行为。

			
		

	





	

		

			

				
					
python函数闭包

				
			

			

				

					算法笨蛋
				

				

					01-23
					
					971
					
				

			

		

		

			
				
闭包
闭包实现了函数的嵌套，也就是说在函数内定义函数，如加法函数：
def sum(a):
	def add(b):
		return a + b   # 内部函数add()引用了外部函数sum()的变量a

	return add   # 外部函数返回的是函数名

在调用时
fun = sum(2)   # sum()返回的是函数，因此fun可做函数使用
print(fun(4))  # 输出6

对于上面加法的例子来说，实际上比写成普通的函数更麻烦。但是闭包却很有价值。再比如，对于一个y=ax+b的式子

			
		

	





	

		

			

				
					
Python 闭包 ( closure )

				
			

			

				

					码呀Bug呀的博客
				

				

					12-20
					
					270
					
				

			

		

		

			
				
>>> def funX(x):
	def funY(y):
		return x * y
	return funY

>>> i = funX(8)
>>> i(5)
40
>>> funX(8)(5)
40

			
		

	





	

		

			

				
					
一些python的高级方法（闭包、装饰器、多线程详解）

				
			

			

				

					qq_54517101的博客
				

				

					07-25
					
					1023
					
				

			

		

		

			
				
定义双层嵌套函数，内层函数可以访问外层函数的变量将内存函数作为外层函数的返回，此内层函数就是闭包函数。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值