基于Python函数的作用域规则和闭包(详解)

作者:再见紫罗兰 时间:2023-09-03 09:00:28 

作用域规则

命名空间是从名称到对象的映射,Python中主要是通过字典实现的,主要有以下几个命名空间:

内置命名空间,包含一些内置函数和内置异常的名称,在Python解释器启动时创建,一直保存到解释器退出。内置命名实际上存在于一个叫__builtins__的模块中,可以通过globals()['__builtins__'].__dict__查看其中的内置函数和内置异常。

全局命名空间,在读入函数所在的模块时创建,通常情况下,模块命名空间也会一直保存到解释器退出。可以通过内置函数globals()查看。

局部命名空间,在函数调用时创建,其中包含函数参数的名称和函数体内赋值的变量名称。在函数返回或者引发了一个函数内部没有处理的异常时删除,每个递归调用有它们自己的局部命名空间。可以通过内置函数locals()查看。

python解析变量名的时候,首先搜索局部命名空间。如果没有找到匹配的名称,它就会搜索全局命名空间。如果解释器在全局命名空间中也找不到匹配值,最终会检查内置命名空间。如果仍然找不到,就会引发NameError异常。

不同命名空间内的名称绝对没有任何关系,比如:


a = 42
def foo():
 a = 13
 print "globals: %s" % globals()
 print "locals: %s" % locals()
 return a
foo()
print "a: %d" % a

结果:


globals: {'a': 42, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Users\\h\\Desktop\\test4.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002C17AC8>, '__doc__': None}
locals: {'a': 13}
a: 42

可见在函数中对变量a赋值会在局部作用域中创建一个新的局部变量a,外部具有相同命名的那个全局变量a不会改变。

在Python中赋值操作总是在最里层的作用域,赋值不会复制数据,只是将命名绑定到对象。删除也是如此,比如在函数中运行del a,也只是从局部命名空间中删除局部变量a,全局变量a不会发生任何改变。

如果使用局部变量时还没有给它赋值,就会引发UnboundLocalError异常:


a = 42
def foo():
 a += 1
 return a
foo()

上述函数中定义了一个局部变量a,赋值语句a += 1会尝试在a赋值之前读取它的值,但全局变量a是不会给局部变量a赋值的。

要想在局部命名空间中对全局变量进行操作,可以使用global语句,global语句明确地将变量声明为属于全局命名空间:


a = 42
def foo():
 global a
 a = 13
 print "globals: %s" % globals()
 print "locals: %s" % locals()
 return a
foo()
print "a: %d" % a

输出:


globals: {'a': 13, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Users\\h\\Desktop\\test4.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002B87AC8>, '__doc__': None}
locals: {}
a: 13

可见全局变量a发生了改变。

Python支持嵌套函数(闭包),但python 2只支持在最里层的作用域和全局命名空间中给变量重新赋值,内部函数是不可以对外部函数中的局部变量重新赋值的,比如:


def countdown(start):
 n = start
 def display():
   print n
 def decrement():
   n -= 1
 while n > 0:
   display()
   decrement()
countdown(10)

运行会报UnboundLocalError异常,python 2中,解决这个问题的方法是把变量放到列表或字典中:


def countdown(start):
 alist = []
 alist.append(start)
 def display():
   print alist[0]
 def decrement():
   alist[0] -= 1
 while alist[0] > 0:
   display()
   decrement()
countdown(10)

在python 3中可以使用nonlocal语句解决这个问题,nonlocal语句会搜索当前调用栈中的下一层函数的定义。:


def countdown(start):
 n = start
 def display():
   print n
 def decrement():
   nonlocal n
   n -= 1
 while n > 0:
   display()
   decrement()
countdown(10)

闭包

闭包(closure)是函数式编程的重要的语法结构,Python也支持这一特性,举例一个嵌套函数:


def foo():
 x = 12
 def bar():
   print x
 return bar
foo()()

输出:12

可以看到内嵌函数可以访问外部函数定义的作用域中的变量,事实上内嵌函数解析名称时首先检查局部作用域,然后从最内层调用函数的作用域开始,搜索所有调用函数的作用域,它们包含非局部但也非全局的命名。

组成函数的语句和语句的执行环境打包在一起,得到的对象就称为闭包。在嵌套函数中,闭包将捕捉内部函数执行所需要的整个环境。

python函数的code对象,或者说字节码中有两个和闭包有关的对象:

co_cellvars: 是一个元组,包含嵌套的函数所引用的局部变量的名字
co_freevars: 是一个元组,保存使用了的外层作用域中的变量名

再看下上面的嵌套函数:


>>> def foo():
   x = 12
   def bar():
     return x
   return bar

>>> foo.func_code.co_cellvars
('x',)
>>> bar = foo()
>>> bar.func_code.co_freevars
('x',)

可以看出外层函数的code对象的co_cellvars保存了内部嵌套函数需要引用的变量的名字,而内层嵌套函数的code对象的co_freevars保存了需要引用外部函数作用域中的变量名字。

在函数编译过程中内部函数会有一个闭包的特殊属性__closure__(func_closure)。__closure__属性是一个由cell对象组成的元组,包含了由多个作用域引用的变量:


>>> bar.func_closure
(<cell at 0x0000000003512C78: int object at 0x0000000000645D80>,)

若要查看闭包中变量的内容:


>>> bar.func_closure[0].cell_contents
12

如果内部函数中不包含对外部函数变量的引用时,__closure__属性是不存在的:


>>> def foo():
   x = 12
   def bar():
     pass
   return bar

>>> bar = foo()
>>> print bar.func_closure
None

当把函数当作对象传递给另外一个函数做参数时,再结合闭包和嵌套函数,然后返回一个函数当做返回结果,就是python装饰器的应用啦。

延迟绑定

需要注意的一点是,python函数的作用域是由代码决定的,也就是静态的,但它们的使用是动态的,是在执行时确定的。


>>> def foo(n):
   return n * i

>>> fs = [foo for i in range(4)]
>>> print fs[0](1)

当你期待结果是0的时候,结果却是3。

这是因为只有在函数foo被执行的时候才会搜索变量i的值, 由于循环已结束, i指向最终值3, 所以都会得到相同的结果。

在闭包中也存在相同的问题:


def foo():
 fs = []
 for i in range(4):
   fs.append(lambda x: x*i)
 return fs
for f in foo():
 print f(1)

返回:

解决方法,一个是为函数参数设置默认值:


>>> fs = [lambda x, i=i: x * i for i in range(4)]
>>> for f in fs:
   print f(1)

另外就是使用闭包了:


>>> def foo(i):
   return lambda x: x * i

>>> fs = [foo(i) for i in range(4)]
>>> for f in fs:
   print f(1)

或者:


>>> for f in map(lambda i: lambda x: i*x, range(4)):
   print f(1)

使用闭包就很类似于偏函数了,也可以使用偏函数:


>>> fs = [functools.partial(lambda x, i: x * i, i) for i in range(4)]
>>> for f in fs:
   print f(1)

这样自由变量i都会优先绑定到闭包函数上。

来源:http://www.cnblogs.com/linxiyue/archive/2017/11/29/7911916.html

标签:Python,闭包,作用域
0
投稿

猜你喜欢

  • Asp Response.Expires 属性介绍

    2008-02-19 17:02:00
  • 使用Python操作PDF文件

    2022-01-01 06:15:12
  • JavaScript简介

    2024-04-10 10:43:17
  • Mysql字符串截取函数SUBSTRING的用法说明

    2024-01-24 14:53:51
  • python3+PyQt5 使用三种不同的简便项窗口部件显示数据的方法

    2021-10-25 12:14:57
  • 通过数据库对Django进行删除字段和删除模型的操作

    2024-01-19 09:28:44
  • 浅谈numpy数组的几种排序方式

    2022-04-24 12:48:15
  • python中利用Future对象异步返回结果示例代码

    2021-09-10 06:59:52
  • gliffy-confluence-plugin-9.1.2插件教程详解

    2022-05-02 06:21:21
  • python将unicode和str互相转化的实现

    2023-07-17 21:36:34
  • 详解Python的三种拷贝方式

    2023-04-20 19:39:20
  • golang常用库之pkg/errors包第三方错误处理包案例详解

    2024-02-14 09:20:38
  • Symfony2实现在controller中获取url的方法

    2023-11-17 17:30:03
  • 探索网页设计中的黄金比例

    2008-10-20 12:26:00
  • Go语言实现简单的一个静态WEB服务器

    2024-04-28 09:12:56
  • JavaScript,5种调用函数的方法[译]

    2009-02-24 16:26:00
  • 详解MySQL中的pid与socket

    2024-01-26 15:07:56
  • 使用pytorch加载并读取COCO数据集的详细操作

    2021-01-04 21:21:24
  • vux-scroller实现移动端上拉加载功能过程解析

    2024-05-09 10:42:21
  • Django学习教程之静态文件的调用详解

    2022-01-03 00:19:45
  • asp之家 网络编程 m.aspxhome.com