python中的闭包函数有哪些-创新互联

本篇文章给大家分享的是有关python中的闭包函数有哪些,小编觉得挺实用的,因此分享给大家学习,希望大家阅读完这篇文章后可以有所收获,话不多说,跟着小编一起来看看吧。

阿里地区ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景,ssl证书未来市场广阔!成为创新互联公司的ssl证书销售渠道,可以享受市场价格4-6折优惠!如果有意向欢迎电话联系或者加微信:028-86922220(备注:SSL证书合作)期待与您的合作!

闭包函数初探

通常我们定义函数都是这样定义的

def foo():
 pass

其实在函数式编程中,函数里面还可以嵌套函数,如下面这样

def foo():
 print("hello world in foo")
 
 def bar():
 print("hello world in bar")

此时我们调用foo函数,执行结果会是什么样子的呢??

hello world in foo

结果如上所示,只会执行foo函数的第一层函数,bar函数是不会被执行的。为什么呢

实际上来说,不管函数写在哪个部分,那都只是定义了一个函数,只有这个函数被调用,函数内部的语句才会被执行

在上面的例子中,bar函数虽然在foo函数内部定义了,但是并没有被执行,所以bar函数是不会被执行的这样说来,定义在一个函数内部的函数就没什么作用了吗??其实不是这样的。

来看下面的例子,把bar函数作为一个值返回给foo函数,来看执行过程

def foo():
 print("hello world in foo")
 
 def bar():
 print("hello world in bar")
 return bar
f1=foo()
print(f1)

此时,由于bar函数作为一个返回值被返回给了foo,所以foo函数执行结果是有返回值的

此时定义一个变量f1来接收foo函数的执行返回结果,然后打印f1

返回的结果如下

hello world in foo
.bar at 0x0000000002941A60>

可以看到首先打印了foo函数中定义的一个print语句,接着打印的是foo函数中包含的bar函数的内存地址

既然是一个函数的内存地址,当然可以加括号来执行这个函数

def foo():
 print("hello world in foo")
 def bar():
 print("hello world in bar")
 return bar
f1=foo()
f1()

此时,这段代码的执行结果为:

hello world in foo
hello world in bar

两个print语句都被打印出来了。

在上面的例子里,首先定义了一个函数foo,接着在foo函数内部又嵌套定义了一个函数bar,然后返回函数bar的函数名,这就是闭包函数的定义方式。

其实,闭包的定义就是一个函数内部又嵌套了一个函数

来看下面的这段代码

 def foo():
 print("hello world in foo")
 name="python"
 def bar():
  print(name)
  print("hello world in bar")
 return bar
 
 f1=foo()
 f1()

在上面的例子里,在外层函数中定义了一个变量name,然后在内层函数中打印这个变量name

此时执行上面的代码,在打印name这个变量的时候,会先在bar函数内部查找name这个变量,但是bar函数里面是没有name这个变量的,

此时根据python查找变量的LEGB法则,会到bar函数的外面一层去继续查找name这个变量,此时可以找到name这个变量

所以这里打印的foo函数中定义的name的值

执行上面的代码,打印结果如下

hello world in foo
python
hello world in bar

这里要记住很重要的一点就是:

内层函数引用了外层函数的局部变量

来分析下上面的例子中程序的执行过程:

首先运行foo函数,foo函数的执行结果是返回bar的函数名,此时又把foo函数的执行结果定义给了变量f1,
所以此时f1就等于bar这个函数的内存地址,然后f1加括号运行就表示运行了bar函数。
在执行bar函数的过程中,bar函数访问到了外层foo函数中定义的变量,这就是一个典型的闭包函数
那使用闭包函数有什么好处呢??在上面的例子里,f1的值是bar函数的内存地址,f1加括号运行就是在运行bar函数。

又由于f1是一个全局变量,这意味着可以在整个程序的任意位置都可以运行f1函数,此时再定义一个函数,在这个函数内部调用f1函数,

 def foo():
 print("hello world in foo")
 name = "python"
 
 def bar():
  print(name)
  print("hello world in bar")
 return bar
 
 f1 = foo()
 
 def func():
 name = "aaaaa"
 f1()
 func()

来分析一下程序的执行过程:

1.运行func函数,程序会先在内存中申请一块空间以保存name变量的值,然后运行f1函数,f1是在全局中定义的变量,所以一定可以找到f1函数的内存地址

2.f1加括号运行,就是在执行一个闭包函数,这个闭包函数内部引用了name这个变量

3.name这个变量在bar函数的外部已经定义了,所以在func函数内部调用f1函数,也就是bar函数时,其引用的变量依然是foo函数内部定义的name变量,而不是func函数内部定义的name变量,

4.因为f1函数的内部已经包含了name这个函数的值,所以就算在func函数内部也定义了name这个变量,程序执行的结果打印的依然是foo函数内部定义的name的值

程序执行结果

hello world in foo
python
hello world in bar

怎样验证一个函数是闭包函数

首先,闭包函数都有一个特有的属性:closure

在上面的例子里,打印f1的__closure__属性  

 def foo():
 name = "python"
 def bar():
  print(name)
  print("hello world in bar")
 return bar
 f1 = foo()
 print(f1.__closure__)

打印结果如下:

(,)

可以看到__closure__属性的打印结果是一个元组形式的,其值就是f1函数的外层函数作用域

此时可以调用__closure__返回的元组的元素的cell_contents方法打印出name变量的值

 def foo():
 name = "python"
 
 def bar():
  print(name)
  print("hello world in bar")
 return bar
 
 f1 = foo()
 print(f1.__closure__[0].cell_contents)

打印结果如下:

python

可以看到程序已经打印出name变量的值了

即然__closure__的返回结果是一个元组,那么这个元组中一定是可以包含多个值的,看下面的例子

在foo函数内部定义多个变量,然后在bar函数内部打印几个变量的值,

然后运行这个闭包函数,打印闭包函数的__closure__方法   

 def foo():
 print("hello world in foo")
 name1 = "python1"
 name2 = "python2"
 name3 = "python3"
 name4 = "python4" 
 def bar():
  print(name1)
  print(name2)
  print(name3)
  print(name4)
  print("hello world in bar")
 return bar 
 f1 = foo()
 print(f1.__closure__)

程序执行结果

()

由于在foo函数内部定义了4个变量,而且在bar函数内部引用了这4个变量,所以打印这个闭包函数的__closure__方法,返回的元组中就有4个元素

现在可以分别打印返回的元组中的这4个字符串对象的值了   

 def foo():
 name1 = "python1"
 name2 = "python2"
 name3 = "python3"
 name4 = "python4"
 
 def bar():
  print(name1)
  print(name2)
  print(name3)
  print(name4)
  print("hello world in bar")
 return bar 
 f1 = foo()
 print(f1.__closure__[0].cell_contents)
 print(f1.__closure__[1].cell_contents)
 print(f1.__closure__[2].cell_contents)
 print(f1.__closure__[3].cell_contents)

程序执行结果

python1
python2
python3
python4

那么现在还剩下最后一个问题了,那就是闭包函数的内层函数一定要返回吗??

来看下面一个例子

 def foo():
 name = "python1" 
 def bar():
  print(name)
 print(bar.__closure__) 
 foo()

定义了一个嵌套函数,然后这个嵌套函数的内层函数没有被返回,而是直接打印内层函数的__closure__方法,然后直接调用外层函数。

程序执行结果

(,)

依然打印出了内层函数的引用的变量对象

这说明闭包函数的内层函数还一定要返回

闭包函数的内层函数可以调用全局变量吗??

把外层函数内部定义的变量改为全局变量,然后在内层函数中引用这个变量

 name = "python1"
 def foo():
 def bar():
  print(name) 
 print(bar.__closure__)
 f=foo()
 print(f)

程序执行结果

None
None

可以看到,程序的执行结果是两个None,嵌套函数的内层函数的__closure__函数的值为None

这说明foo函数的内层嵌套函数bar调用的全局变量没有成功,所以上面的例子不是一个闭包函数

关于闭包函数的一些总结:

闭包的定义为:

    在函数内部定义的函数,称为内部函数
    内部函数调用了外部函数的局部变量
    即使内部函数返回了,还是可以使用局部变量
    通常闭包函数的内层函数都要被返回给外部函数
    闭包函数的外部函数可以在任何地方被调用,而不再受函数定义时层级的限制

闭包函数的作用

1.闭包函数自带函数作用域

正常意义上的函数,在函数执行过程中查找变量的顺序是一层一层向外找,符合LEGB(Local->Enclose->Global->Built in)法则的,

但是对闭包函数来说,查找变量只会找内部函数外面的那一层,因为闭包函数本身就自带一层作用域,这样才符合"闭包"两个字的意思

2.延迟计算(也叫惰性计算)

看下面的例子

 def func():
 name="python"
 def bar():
  print(name)
 return bar 
 f=func()
 print(f.__closure)

在上面的例子里,执行foo()函数的返回结果是一个包含自带的某种状态的函数,实际上这个函数并没有执行,

以后想执行这个自带状态的函数时,把func()返回结果所赋值的那个变量加括号就可以执行了,

3.要想让一个函数始终保持一种状态,就可以使用闭包

例子:

 name="python" 
 def func():
 print("I like %s" % name) 
 func()

上面的代码执行结果会打印一行:"I like python"

但是我们知道,在不同的地方调用func函数,打印的结果很大可能是不一样的

那么如果我想不管在什么地方调用func函数,打印的结果都是"I like python"时,

就可以使用闭包了。

 def func1(): 
 name="python"
 def func():
  print("I like %s" % name)
 return func
 func=func1()
 func()

如上图所示,在func函数外面再包含一层函数func1,执行func1函数,再把func1函数的返回结果赋值给func这个变量

此时func就是一个闭包函数了,把func函数加括号就可以执行了

以上就是python中的闭包函数有哪些,小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注创新互联成都网站设计公司行业资讯频道。

另外有需要云服务器可以了解下创新互联scvps.cn,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。


网站名称:python中的闭包函数有哪些-创新互联
标题来源:http://myzitong.com/article/ddooed.html