`

转:python 闭包

 
阅读更多
作者:陈伟
链接:https://www.zhihu.com/question/25950466/answer/31731502
来源:知乎
著作权归作者所有,转载请联系作者获得授权。

“在Python中,函数本身也是对象”
这一本质。那不妨慢慢来,从最基本的概念开始,讨论一下这个问题:

1. Python中一切皆对象
这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构,当你执行:
alist = [1, 2, 3]

时,你就创建了一个列表对象,并且用alist这个变量引用它:
<noscript>&lt;img src="https://pic2.zhimg.com/d19b60d824c68780fd863c32fb46226d_b.jpg" data-rawwidth="460" data-rawheight="147" class="origin_image zh-lightbox-thumb" width="460" data-original="https://pic2.zhimg.com/d19b60d824c68780fd863c32fb46226d_r.jpg"&gt;当然你也可以自己定义一个类:</noscript> 当然你也可以自己定义一个类:
class House(object):
    def __init__(self, area, city):
        self.area = area
        self.city = city

    def sell(self, price):
        [...]  #other code
        return price

然后创建一个类的对象:
house = House(200, 'Shanghai')

OK,你立马就在上海有了一套200平米的房子,它有一些属性(area, city),和一些方法(__init__, self):
<noscript>&lt;img src="https://pic2.zhimg.com/5f96cfc3c50822c7f838849a27421805_b.jpg" data-rawwidth="592" data-rawheight="306" class="origin_image zh-lightbox-thumb" width="592" data-original="https://pic2.zhimg.com/5f96cfc3c50822c7f838849a27421805_r.jpg"&gt;</noscript>

2. 函数是第一类对象
和list, tuple, dict以及用House创建的对象一样,当你定义一个函数时,函数也是对象:
def func(a, b):
    return a+b
<noscript>&lt;img src="https://pic1.zhimg.com/e299ef723848572231d5ec51cf96782c_b.jpg" data-rawwidth="418" data-rawheight="156" class="content_image" width="418"&gt;在全局域,函数对象被函数名引用着,它接收两个参数a和b,计算这两个参数的和作为返回值。</noscript> 在全局域,函数对象被函数名引用着,它接收两个参数a和b,计算这两个参数的和作为返回值。

所谓第一类对象,意思是可以用标识符给对象命名,并且对象可以被当作数据处理,例如赋值、作为参数传递给函数,或者作为返回值return 等

因此,你完全可以用其他变量名引用这个函数对象:
add = func

<noscript>&lt;img src="https://pic4.zhimg.com/c45b67c3f4394d4296415730eacf186b_b.jpg" data-rawwidth="434" data-rawheight="174" class="origin_image zh-lightbox-thumb" width="434" data-original="https://pic4.zhimg.com/c45b67c3f4394d4296415730eacf186b_r.jpg"&gt;这样,你就可以像调用func(1, 2)一样,通过新的引用调用函数了:</noscript> 这样,你就可以像调用func(1, 2)一样,通过新的引用调用函数了:
print func(1, 2)
print add(1, 2)  #the same as func(1, 2)
<noscript>&lt;img src="https://pic1.zhimg.com/4d3667d0ff59d50b5120e51c83666ac0_b.jpg" data-rawwidth="555" data-rawheight="105" class="origin_image zh-lightbox-thumb" width="555" data-original="https://pic1.zhimg.com/4d3667d0ff59d50b5120e51c83666ac0_r.jpg"&gt;</noscript>
或者将函数对象作为参数,传递给另一个函数:

def caller_func(f):
    return f(1, 2)

if __name__ == "__main__":
    print caller_func(func)

<noscript>&lt;img src="https://pic2.zhimg.com/12e1beef560929ed34f1b9f075109e31_b.jpg" data-rawwidth="549" data-rawheight="358" class="origin_image zh-lightbox-thumb" width="549" data-original="https://pic2.zhimg.com/12e1beef560929ed34f1b9f075109e31_r.jpg"&gt;</noscript>

可以看到,
  • 函数对象func作为参数传递给caller_func函数,传参过程类似于一个赋值操作f=func;
  • 于是func函数对象,被caller_func函数作用域中的局部变量f引用,f实际指向了函数func;cc
  • 当执行return f(1, 2)的时候,相当于执行了return func(1, 2);
因此输出结果为3。

3. 函数对象 vs 函数调用
无论是把函数赋值给新的标识符,还是作为参数传递给新的函数,针对的都是函数对象本身,而不是函数的调用。

用一个更加简单,但从外观上看,更容易产生混淆的例子来说明这个问题。例如定义了下面这个函数:
def func():
    return "hello,world"

然后分别执行两次赋值:
ref1 = func      #将函数对象赋值给ref1
ref2 = func()       #调用函数,将函数的返回值("hello,world"字符串)赋值给ref2

很多初学者会混淆这两种赋值,通过Python内建的type函数,可以查看一下这两次赋值的结果:
In [4]: type(ref1)
Out[4]: function

In [5]: type(ref2)
Out[5]: str

可以看到,ref1引用了函数对象本身,而ref2则引用了函数的返回值。通过内建的callable函数,可以进一步验证ref1是可调用的,而ref2是不可调用的:
In [9]: callable(ref1)
Out[9]: True

In [10]: callable(ref2)
Out[10]: False

传参的效果与之类似。

4. 闭包&LEGB法则
所谓闭包,就是将组成函数的语句和这些语句的执行环境打包在一起时,得到的对象

听上去的确有些复杂,还是用一个栗子来帮助理解一下。假设我们在foo.py模块中做了如下定义:
#foo.py
filename = "foo.py"

def call_func(f):
    return f()    #如前面介绍的,f引用一个函数对象,然后调用它

在另一个func.py模块中,写下了这样的代码:
#func.py
import foo      #导入foo.py

filename = "func.py"
def show_filename():
    return "filename: %s" % filename

if __name__ == "__main__":
    print foo.call_func(show_filename)   #注意:实际发生调用的位置,是在foo.call_func函数中

当我们用python func.py命令执行func.py时输出结果为:
chiyu@chiyu-PC:~$ python func.py 
filename:func.py

很显然show_filename()函数使用的filename变量的值,是在与它相同环境(func.py模块)中定义的那个。尽管foo.py模块中也定义了同名的filename变量,而且实际调用show_filename的位置也是在foo.py的call_func内部

而对于嵌套函数,这一机制则会表现的更加明显:闭包将会捕捉内层函数执行所需的整个环境
#enclosed.py
import foo
def wrapper():
    filename = "enclosed.py"
    def show_filename():
        return "filename: %s" % filename
    print foo.call_func(show_filename)    #输出:filename: enclosed.py

实际上,每一个函数对象,都有一个指向了该函数定义时所在全局名称空间的__globals__属性:
#show_filename inside wrapper
#show_filename.__globals__

{
'__builtins__': <module '__builtin__' (built-in)>,        #内建作用域环境
'__file__': 'enclosed.py',         
'wrapper': <function wrapper at 0x7f84768b6578>,      #直接外围环境
'__package__': None,            
'__name__': '__main__',        
'foo': <module 'foo' from '/home/chiyu/foo.pyc'>,         #全局环境
'__doc__': None                   
}

当代码执行到show_filename中的return "filename: %s" % filename语句时,解析器按照下面的顺序查找filename变量:
  • Local - 本地函数(show_filename)内部,通过任何方式赋值的,而且没有被global关键字声明为全局变量的filename变量;
  • Enclosing - 直接外围空间(上层函数wrapper)的本地作用域,查找filename变量(如果有多层嵌套,则由内而外逐层查找,直至最外层的函数);
  • Global - 全局空间(模块enclosed.py),在模块顶层赋值的filename变量;
  • Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量;
在任何一层先找到了符合要求的filename变量,则不再向更外层查找。如果直到Builtin层仍然没有找到符合要求的变量,则抛出NameError异常。这就是变量名解析的:LEGB法则。

总结:
  1. 闭包最重要的使用价值在于:封存函数执行的上下文环境
  2. 闭包在其捕捉的执行环境(def语句块所在上下文)中,也遵循LEGB规则逐层查找,直至找到符合要求的变量,或者抛出异常。

5. 装饰器&语法糖(syntax sugar)
那么闭包和装饰器又有什么关系呢?

上文提到闭包的重要特性:封存上下文,这一特性可以巧妙的被用于现有函数的包装,从而为现有函数更加功能。而这就是装饰器。

还是举个例子,代码如下:
#alist = [1, 2, 3, ..., 100]  --> 1+2+3+...+100 = 5050
def lazy_sum():
    return reduce(lambda x, y: x+y, alist)

我们定义了一个函数lazy_sum,作用是对alist中的所有元素求和后返回。alist假设为1到100的整数列表:
alist = range(1, 101)

但是出于某种原因,我并不想马上返回计算结果,而是在之后的某个地方,通过显示的调用输出结果。于是我用一个wrapper函数对其进行包装:
def wrapper():
    alist = range(1, 101)
    def lazy_sum():
        return reduce(lambda x, y: x+y, alist)
    return lazy_sum

lazy_sum = wrapper()        #wrapper() 返回的是lazy_sum函数对象

if __name__  == "__main__":
    lazy_sum()           #5050

这是一个典型的Lazy Evaluation的例子。我们知道,一般情况下,局部变量在函数返回时,就会被垃圾回收器回收,而不能再被使用。但是这里的alist却没有,它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确,实际是包含在了lazy_sum的执行环境中,通过__globals__),从而延长了生命周期。

当在if语句块中调用lazy_sum()的时候,解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表,计算结果,返回5050。

当你需要动态的给已定义的函数增加功能时,比如:参数检查,类似的原理就变得很有用:
def add(a, b):
    return a+b

这是很简单的一个函数:计算a+b的和返回,但我们知道Python是 动态类型+强类型 的语言,你并不能保证用户传入的参数a和b一定是两个整型,他有可能传入了一个整型和一个字符串类型的值:
In [2]: add(1, 2)
Out[2]: 3

In [3]: add(1.2, 3.45)
Out[3]: 4.65

In [4]: add(5, 'hello')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/home/chiyu/<ipython-input-4-f2f9e8aa5eae> in <module>()
----> 1 add(5, 'hello')

/home/chiyu/<ipython-input-1-02b3d3d6caec> in add(a, b)
      1 def add(a, b):
----> 2     return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是,解析器无情的抛出了一个TypeError异常。

动态类型:在运行期间确定变量的类型,python确定一个变量的类型是在你第一次给他赋值的时候;
强类型:有强制的类型定义,你有一个整数,除非显示的类型转换,否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算);

因此,为了更加优雅的使用add函数,我们需要在执行+运算前,对a和b进行参数检查。这时候装饰器就显得非常有用:
import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):
    return a + b

def checkParams(fn):
    def wrapper(a, b):
        if isinstance(a, (int, float)) and isinstance(b, (int, float)):    #检查参数a和b是否都为整型或浮点型
            return fn(a, b)             #是则调用fn(a, b)返回计算结果

        #否则通过logging记录错误信息,并友好退出
        logging.warning("variable 'a' and 'b' cannot be added")   
        return
    return wrapper     #fn引用add,被封存在闭包的执行环境中返回

if __name__ == "__main__":
    #将add函数对象传入,fn指向add
    #等号左侧的add,指向checkParams的返回值wrapper
    add = checkParams(add)      
    add(3, 'hello')     #经过类型检查,不会计算结果,而是记录日志并退出

注意checkParams函数:
  • 首先看参数fn,当我们调用checkParams(add)的时候,它将成为函数对象add的一个本地(Local)引用;
  • 在checkParams内部,我们定义了一个wrapper函数,添加了参数类型检查的功能,然后调用了fn(a, b),根据LEGB法则,解释器将搜索几个作用域,并最终在(Enclosing层)checkParams函数的本地作用域中找到fn;
  • 注意最后的return wrapper,这将创建一个闭包,fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中,不会随着checkParams的返回而被回收;
当调用add = checkParams(add)时,add指向了新的wrapper对象,它添加了参数检查和记录日志的功能,同时又能够通过封存的fn,继续调用原始的add进行+运算。

因此调用add(3, 'hello')将不会返回计算结果,而是打印出日志:
chiyu@chiyu-PC:~$ python func.py 
WARNING:root:variable 'a' and 'b' cannot be added

有人觉得add = checkParams(add)这样的写法未免太过麻烦,于是python提供了一种更优雅的写法,被称为语法糖:
@checkParams
def add(a, b):
    return a + b

这只是一种写法上的优化,解释器仍然会将它转化为add = checkParams(add)来执行。

6. 回归问题
def addspam(fn):
    def new(*args):
        print "spam,spam,spam"
        return fn(*args)
    return new

@addspam
def useful(a,b):
    print a**2+b**2

首先看第二段代码:
  • @addspam装饰器,相当于执行了useful = addspam(useful)。在这里题主有一个理解误区:传递给addspam的参数,是useful这个函数对象本身,而不是它的一个调用结果;

再回到addspam函数体:
  • return new 返回一个闭包,fn被封存在闭包的执行环境中,不会随着addspam函数的返回被回收;
  • 而fn此时是useful的一个引用,当执行return fn(*args)时,实际相当于执行了return useful(*args);


最后附上一张代码执行过程中的引用关系图,希望能帮助你理解:
<noscript>&lt;img src="https://pic1.zhimg.com/b5674ca16f72af11d7a1c70602fbfe10_b.jpg" data-rawwidth="1087" data-rawheight="314" class="origin_image zh-lightbox-thumb" width="1087" data-original="https://pic1.zhimg.com/b5674ca16f72af11d7a1c70602fbfe10_r.jpg"&gt;</noscript>
分享到:
评论

相关推荐

    python高阶闭包练习题

    在Python的世界里,"高阶闭包"是一个高级概念,对于理解函数的内部工作原理和实现更复杂的编程逻辑至关重要。本练习题旨在帮助你深入理解和掌握Python中的高阶闭包。 首先,让我们澄清一下什么是闭包。闭包是Python...

    Python闭包:深入理解与应用场景解析.zip

    Python闭包是编程语言中的一种高级特性,它在函数式编程和面向对象编程中都...在阅读《Python闭包:深入理解与应用场景解析.pdf》这份文档时,你将会更全面地了解闭包的工作原理,以及如何在实际项目中有效利用闭包。

    Python闭包实例closure.py

    Python闭包实例closure.py 简单示例闭包的使用 简单示例闭包的使用

    python中闭包共4页.pdf.zip

    Python中的闭包是一种重要的编程概念,它涉及到函数、作用域和引用等核心概念。闭包在Python编程中扮演着至关重要的角色,特别是在处理高阶函数、数据封装和异步编程等场景。以下是对闭包的详细解释: 1. **闭包的...

    Python实用教程,包括:Python基础,Python高级特性,面向对象编程,多线程,数据库,数据科学,Flas.zip

    这一部分可能会涵盖列表推导式、生成器、装饰器、上下文管理器、元类、闭包等进阶概念。它们使得Python代码更加高效且易于维护,例如,生成器可以减少内存使用,装饰器允许在不修改原函数代码的情况下增加功能。 3...

    python笔试题.docx

    Python 笔试题知识点总结 Python 基础知识笔试题目涵盖了 Python 语言的多个方面,包括基础语法、数据类型、函数、模块、字符串处理、 Unicode 编码、协程等。下面是对每个题目的知识点总结: 1. 非法表示式: ...

    Python 闭包,函数分隔作用域,nonlocal声明非局部变量操作示例

    本文实例讲述了Python 闭包,函数分隔作用域,nonlocal声明非局部变量操作。分享给大家供大家参考,具体如下: 实例对象也可以实现闭包的功能,不过实例对象消耗的资源(内存)比闭包多。 demo.py(闭包): # 闭包,...

    资料:Python入门必备指南.zip

    函数进阶下"则深入讲解了闭包、高阶函数等更高级的主题。 5. **数据序列-字典和集合**:"7. 数据序列-字典和集合"章节专注于两种特殊的数据结构。字典是一种键值对存储,集合是无序且不重复的元素集合。它们在处理...

    多线程精品资源--Python实用教程,包括:Python基础,Python高级特性,面向对象编程,多线程,数据库,.zip

    包括但不限于模块与包的导入、装饰器、生成器、上下文管理器、闭包和作用域等。其中,模块和包是代码组织的重要方式,装饰器可以无侵入地修改函数行为,生成器用于高效处理大数据,上下文管理器则提供了资源获取和...

    对Python闭包与延迟绑定的方法详解

    Python闭包可能会在面试或者是工作中经常碰到,而提到Python的延迟绑定,肯定就离不开闭包的理解,今天总结下 关于闭包的概念以及一个延迟绑定的面试题。 Python闭包 1、什么是闭包,闭包必须满足以下3个条件: 必须...

    python中的闭包函数

    闭包是函数式编程中的一个重要概念,在Python中通过嵌套函数实现闭包。闭包的主要作用是使一个内层函数能够记住并访问外层函数的作用域,即使外层函数执行完毕后,内层函数仍然可以使用外层函数的局部变量。 在...

    Python闭包函数定义与用法分析

    在Python编程中,闭包(closure)是一个非常重要的概念,它是函数式编程的一个重要特性,允许一个函数访问并操作函数外部的变量。闭包在很多语言中都有应用,比如Python、JavaScript等。 闭包函数的定义:在Python...

    pdf:Python进阶文档

    - **函数和模块化**:讨论函数式编程技术,如闭包、高阶函数,以及模块和包的组织。 - **并发和异步编程**:介绍多线程、多进程以及Python的`asyncio`库,用于编写高效的并发代码。 3. **`流畅的Python`**: - *...

    python学习手册(第三版): python入门书籍

    7. 高级话题:可能包括装饰器、上下文管理器、迭代器和生成器、闭包、内存管理等比较高级的概念。 以上知识点是Python编程语言的核心部分,通过这些内容的学习,读者可以建立起扎实的基础,为进一步深入学习其他...

    python基础(补充):python三大器之装饰器.pdf

    在本文中,我们将学习Python中的闭包、装饰器等高级概念。 1. 闭包(Closure) 闭包是指在函数内部定义的函数,并且内部函数可以引用外部函数的参数和局部变量。当外部函数返回内部函数时,相关参数和变量都保存在...

    python-tutorial-books 是关于python 学习的保姆级的教程文档,这里将包含:python基础.zip

    9. **函数式编程**:学习Python中的高阶函数、闭包、装饰器以及生成器等函数式编程特性,提升代码的简洁性和复用性。 10. **Python标准库的使用**:了解常用的Python标准库,如os、sys、datetime、random等,学习...

    Python闭包实现计数器的方法

    本篇文章将深入探讨如何利用Python闭包来实现一个简单的计数器,并解释闭包的基本概念和相关技巧。 首先,我们要理解闭包的核心特征:一个函数内部定义了另一个函数,并且内部函数引用了外部函数的局部变量。当外部...

Global site tag (gtag.js) - Google Analytics