Python / 24 Python 的闭包简介

Python 的闭包简介

闭包是较难理解的概念,Python 初学者可以暂时跳过此节。学习此节时需要理解 “函数是第一类对象” 的概念,在词条 “Python 的 lambda 表达式” 中详细介绍了这一概念

本节首先讲解理解闭包所需要的铺垫知识,最后再引入闭包的定义。

1. 嵌套定义函数

1.1 在函数内部定义函数

Python 允许嵌套定义函数,可以在函数中定义函数,例如:

def outter():
    def inner():
        print('Inside inner')

    print('Inside outter')
    inner()

outter()    
  • 在第 1 行,定义函数 outter
  • 在第 2 行,在函数 outter 内部,定义函数 inner
  • 在第 6 行,在函数 outter 内部,调用函数 inner

函数 inner 定义在函数 outter 中,被称为函数嵌套定义。运行程序,输出结果如下:

Inside outter
Inside inner

1.2 实现信息隐藏

定义在函数内部的函数,对外是不可见的,例如:

def outter():
    def inner():
        print('inside inner')

    print('inside outter')        
    inner()

inner()    
  • 在第 1 行,定义了外部函数 outter
  • 在第 2 行,定义了内部函数 inner
  • 在第 6 行,在函数 outter 中,调用函数 inner
  • 在第 8 行,调用函数 inner

程序运行,输出如下:

Traceback (most recent call last):
  File "visible.py", line 8, in <module>
    inner()
NameError: name 'inner' is not defined

在第 4 行,试图调用定义在函数 outter 内部定义的函数 inner,程序运行时报错:name ‘inner’ is not defined,即找不到函数 inner。

因为函数 inner 是定义在函数 outter 内部的,函数 inner 对外部是不可见的,因此函数 outter 向外界隐藏了实现细节 inner,被称为信息隐藏

1.3 实现信息隐藏的例子

实现一个复杂功能的函数时,在函数内部定义大量的辅助函数,这些辅助函数对外不可见。例如,假设要实现一个函数 complex,函数的功能非常复杂,将函数 complex 的功能分解为 3 个子功能,使用三个辅助函数 f1、f2、f3 完成对应的子功能,代码如下:

def f1():
    print('Inside f1')

def f2():
    print('Inside f2')

def f3():
    print('Inside f3')

def complex():
    print('Inside complex')
    f1()
    f2()
    f3()
  • 在第 1 行,定义了辅助函数 f1
  • 在第 4 行,定义了辅助函数 f2
  • 在第 7 行,定义了辅助函数 f3
  • 在第 10 行,定义了主函数 complex,它通过调用 f1、f2、f3 实现自己的功能

在以上的实现中,函数 f1、f2、f3 是用于实现 complex 的辅助函数,我们希望它们仅仅能够被 complex 调用,而不会被其它函数调用。如果可以将函数 f1、f2、f3 定义在函数 complex 的内部,如下所示:

def complex():
    def f1():
        print('Inside f1')
    def f2():
        print('Inside f2')
    def f3():
        print('Inside f3')

    print('Inside complex')
    f1()
    f2()
    f3()
  • 在第 2 行,在函数 complex 内部定义函数 f1
  • 在第 4 行,在函数 complex 内部定义函数 f2
  • 在第 6 行,在函数 complex 内部定义函数 f3
  • 在第 10 行到第 12 行,调用 f1、f2、f3 实现函数 complex 的功能

2. 内部函数访问外部函数的局部变量

嵌套定义函数时,内部函数可能需要访问外部函数的变量,例子代码如下:

def outter():
    local = 123

    def inner(local):
        print('Inside inner, local = %d', local)

    inner(local)

outter()    
  • 在第 1 行,定义了外部函数 outter
  • 在第 2 行,定义了函数 outter 的局部变量 local
  • 在第 4 行,定义了内部函数 inner
    • 函数 inner 需要访问函数 outter 的局部变量 local
  • 在第 7 行,将函数 outter 的局部变量 local 作为参数传递给函数 inner
    • 在第 5 行,函数 inner 就可以访问函数 outter 的局部变量 local

程序运行结果如下:

Inside inner, local = 123

在上面的例子中,将外部函数 outter 的局部变量 local 作为参数传递给内部函数 inner。Python 允许内部函数 inner 不通过参数传递直接访问外部函数 outter 的局部变量,简化了参数传递,代码如下:

def outter():
    local = 123

    def inner():
        print('Inside inner, local = %d', local)

    inner()
  • 在第 1 行,定义了外部函数 outter
  • 在第 2 行,定义了函数 outter 的局部变量 local
  • 在第 4 行,定义了内部函数 inner
    • 函数 inner 需要访问函数 outter 的局部变量 local
  • 在第 5 行,函数 inner 可以直接访问函数 outter 的局部变量 local
  • 在第 7 行,不用传递参数,直接调用函数 inner()

3. 局部变量的生命周期

通常情况下,函数执行完后,函数内部的局部变量就不存在了。在嵌套定义函数的情况下,如果内部函数访问了外部函数的局部变量,外部函数执行完毕后,内部函数仍然可以访问外部函数的局部变量。示例代码如下:

def outter():
    local = 123

    def inner():
        print('Inside inner, local = ' % local)

    return inner

closure = outter()
closure()
  • 在第 1 行,定义了外部函数 outter
  • 在第 2 行,定义了函数 outter 的局部变量 local
  • 在第 4 行,定义了内部函数 inner
    • 函数 inner 需要访问函数 outter 的局部变量 local
  • 在第 7 行,将函数 inner 作为值返回
  • 在第 9 行,调用函数 outter(),将返回值保存到变量 closure 中
  • 在第 10 行,调用函数 closure()

运行程序,输出结果如下:

Inside inner, local = 123

注意:在第 10 行,调用函数 closure() 时,外部函数 outter 已经执行完,外部函数 outter 将内部函数 inner 返回并保存到变量 closure。调用函数 closure() 相当于调用内部函数 inner(),因此,在外部函数 outter 已经执行完的情况下,内部函数 inner 仍然可以访问外部函数的局部变量 local

4. 闭包的概念

闭包的英文是 closure,维基百科中闭包的严谨定义如下:

在计算机科学中,闭包(英语:Closure),又称词法闭包(Lexical Closure)或函数闭包(function closures),是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在,即使已经离开了创造它的环境也不例外。—— 维基百科

在本节,以上一节具体的例子说明和理解闭包的概念,上一节的例子程序如下:

def outter():
    local = 123

    def inner():
        print('Inside inner, local = ' % local)

    return inner

closure = outter()
closure()
  • 在第 2 行,局部变量 local 就是自由变量
  • 在第 5 行,内部函数 inner 引用了局部变量 local (即自由变量)

因此,对照闭包的定义,外部函数定义了局部变量 local,引用了局部变量 local 的内部函数 inner 就是闭包。闭包的独特之处在于:外部函数 outter 创造了局部变量 local, 即使外部函数 outter 已经执行完,内部函数 inner 仍然可以继续访问它引用的局部变量 local。

5. 闭包的应用

5.1 概述

闭包经常用于 GUI 编程的事件响应处理函数。编程语言 Javascript 被用于浏览器的用户界面交互,使用 Javascript 编写事件响应处理函数时,闭包也是经常提及的知识点。

本小节通过编写一个简单的 Python GUI 程序,了解为什么需要使用闭包的语法特性,才方便实现功能需求。

5.2 Tk 简介

Tkinter 是 Python 的标准 GUI 库,Python 使用 Tkinter 可以快速的创建 GUI 应用程序。由于 Tkinter 是内置到 python 的安装包中,只要安装好 Python 之后就能使用 Tkinter 库。

由于 Tkinter 简单易学并且不需要安装,因此选择使用 Tk 编写应用闭包的例子程序。

5.3 例子 1:显示一个窗口

下面使用 Tk 编写一个显示窗口的程序,代码如下:

import tkinter

root = tkinter.Tk()
root.mainloop()
  • 在第 1 行,引入 Tk 库,Tk 库的名称是 tkinter
  • 在第 3 行,tkinter.Tk 方法会创建一个窗口 root
  • 在第 4 行,root.mainloop 方法等待用户的操作

运行程序,显示输出如下:
图片描述

5.4 例子 2:显示一个 button

下面使用 Tk 编写一个显示 button 的程序,代码如下:

import tkinter

root = tkinter.Tk()
button = tkinter.Button(root, text = 'Button')
button.pack()
root.mainloop()
  • 在第 4 行,tkinter.Button 方法创建一个新的 Button,它有两个参数:第一个参数 root,指定在 root 窗口中创建 Button;第二个参数 text,指定新创建 Button 的标签
  • 在第 5 行,button.pack 方法将 button 放置在 root 窗口中

运行程序,显示输出如下:
图片描述

5.5 例子 3:为 button 增加一个事件处理函数

当 button 被点击时,希望程序得到通知,需要为 button 增加一个事件处理函数,代码如下:

import tkinter

def on_button_click():
    print('Button is clicked')

root = tkinter.Tk()
button = tkinter.Button(root, text = 'Button', command = on_button_click)
button.pack()
root.mainloop()
  • 在第 3 行,定义了函数 on_button_click,当用户点击 button 时,程序得到通知,执行 on_btton_click
  • 在第 4 行,函数 on_button_click 在控制台打印输出 ‘Button is clicked’
  • 在第 7 行,tkinter.Button 创建一个 Button,设置 3 个参数
    • 参数 root,表示在 root 窗口中创建 button
    • 参数 text,表示 button 的标签
    • 参数 command,表示当 button 被点击时,对应的事件处理函数
  • 在第 8 行,root.mainloop 等待用户的操作,当用户点击 button 时,程序会执行 button 对应的事件处理函数,即执行 on_button_click

运行程序,显示输出如下:

图片描述
当用户点击 button 时,执行 on_button_click,在控制台中打印 ‘Button is clicked’,显示输出如下:

图片描述

5.6 如何实现计算器

由于篇幅,本节没有实现一个完整的计算器,在这里仅仅讨论实现计算器程序的关键要点。windows 自带的计算器的界面如下所示:

计算器向用户展示各种按钮,包括:
  • 数字按键,0、1、2、3、4、5、6、7、9
  • 运算符按键,+、-、*、\、=

用户在点击某个按键时,程序得到通知:按键被点击了,但是这样的信息还不够,为了实现运算逻辑,还需要知道具体是哪一个按键被点击了

为了区分是哪一个按键被点击了,可以为不同的按键设定不同的按键处理函数,如下所示:

import tkinter

def on_button0_click():
    print('Button 0 is clicked')

def on_button1_click():
    print('Button 1 is clicked')

def on_button2_click():
    print('Button 2 is clicked')

root = tkinter.Tk()

button0 = tkinter.Button(root, text = 'Button 0', command = on_button0_click)
button0.pack()

button1 = tkinter.Button(root, text = 'Button 1', command = on_button0_click)
button1.pack()

button2 = tkinter.Button(root, text = 'Button 2', command = on_button0_click)
button2.pack()

root.mainloop()

为了节省篇幅,这里仅仅处理了 3 个按键。显然,这样的方式是很不合理的,在一个完整的计算器程序中,存在 20 多个按键,如果对每个按键都编写一个事件处理函数,就需要编写 20 多个事件处理函数。在下面的小节中,通过使用闭包解决这个问题。

5.7 例子 4:使用闭包为多个 button 增加事件处理函数

在上面的小节中,面临的问题是:需要为每个 button 编写一个事件处理函数。本小节编写一个事件处理函数响应所有的按键点击事件,代码如下:

import tkinter

def build_button(root, i):
    def on_button_click():
        print('Button %d is clicked' % i)

    title = 'Button ' + str(i)
    button = tkinter.Button(root, text = title, command = on_button_click)
    button.pack()

root = tkinter.Tk()
for i in range(3):
    build_button(root, i)
root.mainloop()
  • 在第 11 行,tkinter.Tk 创建窗口 root
  • 在第 12 行,使用 for 循环调用 build_button 创建 3 个 button
  • 在第 14 行,root.mainloop 等待用户操作
  • 在第 3 行,定义函数 build_button 创建 1 个 button
    • 参数 root,表示在 root 窗口中创建 button
    • 参数 i,表示 button 的序号
  • 在第 4 行,定义事件处理函数 on_button_click
    • build_button 是外部函数
    • on_button_click 是内部函数
    • 在第 5 行,打印外部函数 build_button 的参数 i,因此 on_button_click 是一个闭包函数
  • 在第 7 行,根据 button 的序号 i 设置 button 的标签
  • 在第 7 行,创建一个 button,设置标签和事件处理函数

运行程序,显示输出如下:

图片描述
当用户点击不同的 button 时,都是执行 on_button_click,但在控制台中打印的字符串是不一样的,显示输出如下:
图片描述
在这个例子中,外部函数 build_button 提供了参数 i 用于区分 button,内部函数 on_button_click 可以访问外部函数的参数。因此,当 button 被点击时,通过参数 i 知道是哪一个 button 被点击了,编写 1 个事件处理函数就可以处理多个 button 的点击事件,即使用闭包就很自然的解决了实现计算器程序需要面临的问题。

6. 小结

从概念上来看这一个小节还是比较晦涩的,我在文章的开头也说过了初学者可以先跳过这一小节,等后面在转过头来学习。闭包这个概念非常的重要,面试中有很多面试官喜欢问闭包相关的问题,大家一定要多看几遍,彻底掌握闭包。