专题笔记,基于Python函数的作用域规则和闭包

作者: 化工塑胶  发布:2019-11-26

学会装饰器,Python更进阶

函数作用域到闭包到装饰器讲解,及闭包和装饰器的运用。

  • [√] 慕课网Meshare_huang老师: python进阶

mark

基于Python函数的作用域规则和闭包(详解),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函数的作用域规则和闭包(详解)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持帮客之家。

作用域规则 命名空间是从名称到对象的映射,Python中主要是通过字典实现的,主要有以...

函数作用域

介绍 Python 的函数作用域,了解函数作用域 LEGB 间关系。

主要内容:

  • 函数作用域LEGB
  • 闭包理解与使用
  • 装饰器

LEGB: L>E>G>B

  • L: local 函数内部作用域
  • E: enclosing 函数内部与内嵌函数之间(主要是内置函数对我们函数变量的一个引用,称之为闭包)
  • G: global 全局作用域: 我们所定义的全局变量。
  • B: build-in 内置作用域: Python解释器默认导入的一些变量。

build-in比如:tuplelist元组等。

知识点: LEGB原则: 首先从函数内部作用域查找,然后去enclosing作用域中去查找,然后依次是全局内置

例子(使用Python3.4版本 + sublimeText):

passline = 60          #passline 是全局变量(global)
def func(val):
    if val >= passline:
        print ('pass')
    else:
        print ('failed')

func(89)

运行结果:

pass

分析:

  • 当我们定义一个函数时,会引入一个作用域:L: local.
  • 当我们对于func函数进行调用时,val就是我们的一个本地变量。
  • 在函数内部并没有定义passline 的值。这个时候回去全局变量找查找。如果全局没有还会继续向上查找B: build-in

当总分变为150.我们的passline应该设为90,如果我们不想修改全局的passline,
我们可以在函数内部定义新的passline。因为L>G,所以会以我们自己函数内部的local域为准。

实现代码:

passline = 60          #passline 是全局变量(global)
def func(val):
    passline = 90      #这里的passline是函数内部作用域(local)
    if val >= passline:
        print ('pass')
    else:
        print ('failed')

func(89)

运行结果:

failed

Python解释器查找顺序为L-->E-->G-->B,如果已经找到,就不会找更上层。

如果我们需要拿到两个分数中的更大值。

实现代码:

def Max(val1,val2):
    return max(val1,val2)

print (Max(90,100))

运行结果:

100

Max函数内部引用了一个内置函数方法max.这个内置方法在Max函数中以及整个文件中都没有定义。

这个max存在于我们的build-in.Python解释器在运行时会自动导入内置的方法。比如list,tuple

函数内部的函数产生enclosing

实现代码:

passline = 60          #passline 是全局变量(global)
def func(val):
    passline = 90      #这里的passline是函数内部作用域(local)
    if val >= passline:
        print ('pass')
    else:
        print ('failed')
    def in_func():
        print (val)
    # 调用方式1
    in_func()
    # 调用方式2:将in_func()返回。这样我们就可以在外部调用。
func(89)

运行结果:

failed
89

val变量的查找过程: print (val) 中val的查找过程。

  • in_func()内部并没有定义这个val的值。也就是local作用域中没有这个值.
  • 下一步我们就会去enclosing作用域查找。也就是我们的func(val)中引入的有val变量。
  • 找到传入的val89

什么是闭包

介绍什么是闭包,为什么使用闭包,闭包作用

装饰器之闭包1

closure:内部函数对enclosig作用域的变量进行引用

概念:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)也就是enclosig作用域的变量进行引用,那么内部函数就被认为是闭包(closure)

函数实质与属性

  • 函数是一个对象
  • 函数执行完之后内部变量回收(如果我们中间产生一个变量,这个变量返回那么他不会被回收: 因为他的引用计数还补为0)
  • 作为一个对象函数拥有自己的属性(闭包函数的特殊属性)
  • 函数返回值

正常的调用参考上一章代码。

passline = 60          #passline 是全局变量(global)
def func(val):
    passline = 90     
    if val >= passline:
        print ('pass')
    else:
        print ('failed')
    def in_func():
        print (val)
    in_func()   
    return in_func # in_func是func内部的一个函数对象。
f = func(89) #使用f来接收返回值
f() #infunc

运行结果:

failed
89
89

func执行完成之后,他的val值就会消失。但是我们再次调用f()
因为infunc的引用计数还没有归零。所以会一直保留。

  • 当我们这时候运行f()val值是哪来的呢?
print (f.__closure__)

运行结果

(<cell at 0x0000000005236C48: int object at 0x00000000052169F8>,)

这里面有一个int object 地址为: 0x00000000052169F8

添加一行查看传入funcvalid值(%x 表示使用16进制打印。id()可打印出valid)

def func(val):
    print ('%x'%id(val))

mark

可以看出valueid值和__closure__中的那个int object的值一样。

如果我引用了外部enclosing的值。会将该值保存在函数的属性中。
当我们调用f()时并没有去代码中查找。而是去函数的属性(Local域)中查找.

可以理解为在in_func定义的时候,函数属性中会添加(val,)
这个属性的值是一个元组。是不能变得。

总分从100150涉及到passline的取值问题。

passline = 60  #100      
def func(val):
    passline = 90 # 150

最常用的解决方案是定义两个函数分别处理:

实现代码:

def func_150(val):
    passline = 90 # 150    
    if val >= passline:
        print ('pass')
    else:
        print ('failed')
def func_100(val):
    passline = 60 # 150    
    if val >= passline:
        print ('pass')
    else:
        print ('failed')
func_100(89) 
func_150(89)

运行结果:

pass
failed

上面两个函数在处理逻辑上基本一致,如果后期对于打印出来的信息要做修改,就得修改两遍。

如要为print添加数值的显示。

def func_150(val):
    print ('%d pass' %val)
def func_100(val):
    print ('%d pass' %val)

所有的改动都得做两遍。(这里想起了c++的模板)

进阶版修改:

def  set_passline(passline): #passline = 60
    def cmp(val): #cmp 的__closure__属性中加入passline
        if val >= passline:
            print ('%x'%id(passline))
            print ('pass')
        else:
            print ('%x'%id(passline))
            print ('failed')
    return cmp

f_100 = set_passline(60)
f_150 = set_passline(90)
print (type(f_100)) # f_100就是一个函数对象。__closure__属性中存放着passline

print (f_100.__closure__)
f_100(89)
print (f_150.__closure__)
f_150(89)

mark

理解:闭包就是内部函数(cmp)对于外层函数(set_passline)变量(passline)的使用(也就是对enclosing作用域变量的使用),会将我们使用的这个变量(passline)放到我们的__closure__这个属性中。当我们内部函数处理时会直接对于这个属性值进行使用。

闭包的作用:

  • 封装
  • 代码复用

本文由88必发手机版发布于化工塑胶,转载请注明出处:专题笔记,基于Python函数的作用域规则和闭包

关键词:

上一篇:没有了
下一篇:没有了