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

作用域规则

命名空间是从名称到对象的映射,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都会优先绑定到闭包函数上。

以上这篇基于Python函数的作用域规则和闭包(详解)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 基于Python闭包及其作用域详解

    关于Python作用域的知识在python作用域有相应的笔记,这个笔记是关于Python闭包及其作用域的详细的笔记 如果在一个内部函数里,对一个外部作用域(但不是全局作用域)的变量进行引用,那么内部函数就被称为闭包(closure),而这个被内部函数引用的变量则被成为自由变量 闭包和函数调用没多少相关,而是关于使用定义在其他作用域的变量 命名空间和作用域 我们把命名空间看做一个大型的字典类型(Dict),里面包含了所有变量的名字和值的映射关系.在 Python 中,作用域实际上可以看做是"在当前

  • Python中的作用域规则详解

    Python是静态作用域语言,尽管它自身是一个动态语言.也就是说,在Python中变量的作用域是由它在源代码中的位置决定的,这与C有些相似,但是Python与C在作用域方面的差异还是非常明显的. 接下来会谈论Python的作用域规则,在这中间也会说明一下Python与C在作用域方面的不同. 在Python 2.0及之前的版本中,Python只支持3种作用域,即局部作用域,全局作用域,内置作用域:在Python 2.2中,Python正式引入了一种新的作用域 --- 嵌套作用域:在Python 2

  • 浅谈python函数之作用域(python3.5)

    1 基本概念 1.1 命名空间 (namespace) 命名空间是变量名到对象的映射(name -> obj).目前大多数的命名空间以类似于python字典的形式实现,实现形式在未来可能发生变化.命名空间举例:内置变量(内置函数abs, 内置的异常等),模块中的全局变量,函数调用时的局部变量.在某种意义上讲,对象的属性也形成一个命名空间.重要的是,不同的命名空间中的变量没有任何关联,两个不同的命名空间中可以包含相同的变量名. 命名空间有不同的创建时间和生命周期: •内置变量命名空间在python

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

    作用域规则 命名空间是从名称到对象的映射,Python中主要是通过字典实现的,主要有以下几个命名空间: 内置命名空间,包含一些内置函数和内置异常的名称,在Python解释器启动时创建,一直保存到解释器退出.内置命名实际上存在于一个叫__builtins__的模块中,可以通过globals()['__builtins__'].__dict__查看其中的内置函数和内置异常. 全局命名空间,在读入函数所在的模块时创建,通常情况下,模块命名空间也会一直保存到解释器退出.可以通过内置函数globals()

  • 浅谈Python中的作用域规则和闭包

    在对Python中的闭包进行简单分析之前,我们先了解一下Python中的作用域规则.关于Python中作用域的详细知识,有很多的博文都进行了介绍.这里我们先从一个简单的例子入手. Python中的作用域 假设在交互式命令行中定义如下的函数: >>> a = 1 >>> def foo(): b = 2 c = 3 print "locals: %s" % locals() return "result: %d" % (a + b

  • python中函数总结之装饰器闭包详解

    1.前言 函数也是一个对象,从而可以增加属性,使用句点来表示属性. 如果内部函数的定义包含了在外部函数中定义的对象的引用(外部对象可以是在外部函数之外),那么内部函数被称之为闭包. 2.装饰器 装饰器就是包装原来的函数,从而在不需要修改原来代码的基础之上,可以做更多的事情. 装饰器语法如下: @deco2 @deco1 def func(arg1,arg2...): pass 这个表示了有两个装饰器的函数,那么表示的含义为:func = deco2(deco1(func)) 无参装饰器语法如下:

  • 基于Python制作炸金花游戏的过程详解

    目录 前言 一.思路 二.解决方案 三.总结 前言 <诈金花>又叫三张牌,是在全国广泛流传的一种民间多人纸牌游戏.比如JJ比赛中的诈金花(赢三张),具有独特的比牌规则.游戏过程中需要考验玩家的胆略和智慧.--<百度百科> 前几天在交流群里边,有个叫[^-^]的粉丝分享了一道扑克牌诈金花的题目,要求用Python实现,题目如下: 自己写一个程序,实现发牌.比大小判断输赢. 游戏规则: 一付扑克牌,去掉大小王,每个玩家发3张牌,最后比大小,看谁赢. 有以下几种牌: 豹子:三张一样的牌,

  • 基于python中staticmethod和classmethod的区别(详解)

    例子 class A(object): def foo(self,x): print "executing foo(%s,%s)"%(self,x) @classmethod def class_foo(cls,x): print "executing class_foo(%s,%s)"%(cls,x) @staticmethod def static_foo(x): print "executing static_foo(%s)"%x a=A(

  • 基于Python对象引用、可变性和垃圾回收详解

    变量不是盒子 在示例所示的交互式控制台中,无法使用"变量是盒子"做解释.图说明了在 Python 中为什么不能使用盒子比喻,而便利贴则指出了变量的正确工作方式. 变量 a 和 b 引用同一个列表,而不是那个列表的副本 >>> a = [1, 2, 3] >>> b = a >>> a.append(4) >>> b [1, 2, 3, 4] 如果把变量想象为盒子,那么无法解释 Python 中的赋值:应该把变量视作

  • 基于Python对数据shape的常见操作详解

    这一阵在用python做DRL建模的时候,尤其是在配合使用tensorflow的时候,加上tensorflow是先搭框架再跑数据,所以调试起来很不方便,经常遇到输入数据或者中间数据shape的类型不统一,导致一些op老是报错.而且由于水平菜,所以一些常用的数据shape转换操作也经常百度了还是忘,所以想再整理一下. 一.数据的基本属性 求一组数据的长度 a = [1,2,3,4,5,6,7,8,9,10,11,12] print(len(a)) print(np.size(a)) 求一组数据的s

  • 基于Python的身份证验证识别和数据处理详解

    根据GB11643-1999公民身份证号码是特征组合码,由十七位数字本体码和一位数字校验码组成,排列顺序从左至右依次为: 六位数字地址码八位数字出生日期码三位数字顺序码一位数字校验码(数字10用罗马X表示) 校验系统: 校验码采用ISO7064:1983,MOD11-2校验码系统(图为校验规则样例) 用身份证号的前17位的每一位号码字符值分别乘上对应的加权因子值,得到的结果求和后对11进行取余,最后的结果放到表2检验码字符值..换算关系表中得出最后的一位身份证号码 代码: # coding=ut

  • 基于Python中capitalize()与title()的区别详解

    capitalize()与title()都可以实现字符串首字母大写. 主要区别在于: capitalize(): 字符串第一个字母大写 title(): 字符串内的所有单词的首字母大写 例如: >>> str='huang bi quan' >>> str.capitalize() 'Huang bi quan' #第一个字母大写 >>> str.title() 'Huang Bi Quan' #所有单词的首字母大写 非字母开头的情况: >>

  • 基于python if 判断选择结构的实例详解

    代码执行结构为顺序结构.选择结构.循环结构. python判断选择结构[if] if 判断条件 #进行判断条件满足之后执行下方语句 执行语句 elif 判断条件 #在不满足上面所有条件基础上进行条件筛选匹配之后执行下方语句 执行语句 else #再不满足上面所有的添加下执行下方语句 执行语句 下面举一个简单的例子,看兜里有多少钱来决定吃什么饭. douliqian=2 if douliqian>200: print("小龙虾走起!!0.0") elif douliqian>

随机推荐