Python 闭包原理与实战：从函数对象到并行计算

Python 闭包原理与实战：从函数对象到并行计算

前言：

闭包（closure）是函数式编程中至关重要的语法结构。函数式编程是一种编程范式，与面向过程编程和面向对象编程并列。在面向过程编程中，我们使用函数（function）来组织代码；在面向对象编程中，则使用对象（object）。函数和对象的核心目的都是按照特定逻辑组织代码，并提升代码的可重复使用性（reusability）。闭包作为一种代码组织方式，同样旨在提高代码的可复用性。

不同编程语言实现闭包的方式各异。Python 以函数对象为基础，为闭包这一语法结构提供支持（我们在特殊方法与多范式的讨论中，已多次看到 Python 利用对象实现特殊语法的案例）。在 Python 中，一切皆对象，函数这一语法结构本身也是一个对象。我们可以像使用普通对象一样使用函数对象，例如修改函数对象的名称，或将函数对象作为参数进行传递。

函数对象的作用域

与其他对象类似，函数对象也有其存在的范围，即作用域。函数对象通过 def 语句定义，其作用域与 def 所在的层级一致。例如，在 line_conf 函数的隶属范围内定义的函数 line，只能在 line_conf 的隶属范围内被调用。

def line_conf():
  def line(x):
    return 2*x+1
  print(line(5))  # within the scope


line_conf()
print(line(5))    # out of the scope

line 函数定义了一条直线（y = 2x + 1）。可以看到，在 line_conf() 内部可以调用 line 函数，但在作用域之外调用 line 会引发如下错误：

NameError: name 'line' is not defined

这表明当前调用已处于作用域之外。

同样，如果使用 lambda 定义函数，那么函数对象的作用域与 lambda 所在的层级相同。

闭包

既然函数是一个对象，它就可以作为某个函数的返回结果。

def line_conf():
  def line(x):
    return 2*x+1
  return line    # return a function object

my_line = line_conf()
print(my_line(5))   

上述代码可以成功运行。line_conf 的返回结果被赋值给 line 对象。上述代码将打印 11。

如果 line() 的定义中引用了外部的变量，会发生什么呢？

def line_conf():
  b = 15
  def line(x):
    return 2*x+b
  return line    # return a function object

b = 5
my_line = line_conf()
print(my_line(5))    

我们可以看到，line 定义的隶属程序块中引用了高层级的变量 b，但 b 的信息存在于 line 的定义之外（b 的定义并不在 line 的隶属程序块中）。我们将 b 称为 line 的环境变量。事实上，当 line 作为 line_conf 的返回值时，line 中已经包含了 b 的取值（尽管 b 并不隶属于 line）。

上述代码将打印 25，这意味着 line 所参照的 b 值是函数对象定义时可供参考的 b 值，而不是使用时的 b 值。

一个函数与其环境变量结合在一起，就构成了一个闭包（closure）。在 Python 中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的 __closure__ 属性中。例如以下代码：

def line_conf():
  b = 15
  def line(x):
    return 2*x+b
  return line    # return a function object

b = 5
my_line = line_conf()
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)

__closure__ 里包含了一个元组（tuple）。这个元组中的每个元素是 cell 类型的对象。我们看到第一个 cell 包含的就是整数 15，也就是我们创建闭包时的环境变量 b 的取值。

下面看一个闭包的实际例子：

def line_conf(a, b):
  def line(x):
    return ax + b
  return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))

在这个例子中，函数 line 与环境变量 a、b 构成闭包。在创建闭包时，我们通过 line_conf 的参数 a、b 说明了这两个环境变量的取值，从而确定了函数的最终形式（y = x + 1 和 y = 4x + 5）。我们只需要变换参数 a、b，就可以获得不同的直线表达函数。由此可以看出，闭包也具有提高代码可复用性的作用。

如果没有闭包，每次创建直线函数时都需要同时说明 a、b、x。这样就需要传递更多的参数，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函。line 函数定义了一种广泛意义的函数，这个函数的一些方面已经确定（必须是直线），但另一些方面（比如 a 和 b 参数待定）。随后，我们根据 line_conf 传递来的参数，通过闭包的形式，将最终函数确定下来。

闭包与并行运算

闭包有效地减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下，我们可以让每台电脑负责一个函数，然后将一台电脑的输出和下一台电脑的输入串联起来。最终，我们像流水线一样工作，从串联的电脑集群一端输入数据，从另一端输出数据。这种情境最适合只有一个参数输入的函数，而闭包就可以实现这一目的。

并行运算正成为一个热点，这也是函数式编程重新流行的一个重要原因。函数式编程早在 1950 年代就已经存在，但应用并不广泛。然而，我们上面描述的流水线式的工作并行集群过程，正适合函数式编程。由于函数式编程这一天然优势，越来越多的语言也开始加入对函数式编程范式的支持。

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！