[Python之路] 闭包

一、思考一个问题

我们要给定一个x，要求一条直线上x对应的y的值。公式是y = kx+b。

我们需要用k，b来确定这条直线，则我们实现的函数应该有3个参数：

def line(k, b, x):
    print(k * x + b)


line(1, 3, 4)
line(1, 3, 5)
line(1, 3, 6)

可以看到，我们每次修改x都要重新传入k和b。

我们也可以用全局变量来实现：

k = 1
b = 3


def line(x):
    print(k * x + b)


line(4)
line(5)
line(6)

k和b为全局变量，但如果我们想要另外一条不同的直线时，则还需要重新定义k和b的值，同样不合理。而且全局变量会暴露给其他不相关的函数，容易造成冲突，或代码混乱。

用面向对象来实现：

class Line(object):
    def __init__(self, k, b):
        self.k = k
        self.b = b

    def create_y(self, x):
        print(self.k * x + self.b)


l1 = Line(1, 3)
l1.create_y(4)
l1.create_y(5)
l1.create_y(6)

用类和对象来实现肯定是可以的，但是这么一个简单的功能使用面向对象比较浪费资源。

二、使用闭包

def line(k, b):
    def create_y(x):
        print(k * x + b)

    return create_y


l1 = line(1, 3)
l1(4)
l1(5)
l1(6)

从以上代码可以直观的看到，闭包有以下几个条件：

1.在一个外函数中定义了一个内函数。

2.内函数里运用了外函数的临时变量。

3.并且外函数的返回值是内函数的引用。

一个函数结束的时候，会把自己的临时变量都释放给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量和内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

三、内层函数修改外层函数临时变量

def line(k, b):
    multi = 10;

    def create_y(x):
        print((k * x + b) * multi)

    return create_y


l1 = line(1, 3)
l1(4)
l1(5)
l1(6)

假设外层函数中有一个multi变量，这个变量可以提供给内层函数访问，但是如果内层函数想修改这个multi变量怎么办呢？

在python3.x中，我们可以使用nonlocal关键字来实现：

def line(k, b):
    multi = 10;

    def create_y(x):
        nonlocal multi
        multi = 5
        print((k * x + b) * multi)

    return create_y


l1 = line(1, 3)
l1(4)
l1(5)
l1(6)

这个nonlocal类似与global的作用，但是global是用于修改全局变量，而nonlocal是用于修改闭包中的外层临时变量。

如果在python2.x中，则不存在nonlocal关键字，我们可以通过将multi变为可变类型数据来实现：

def line(k, b):
    # python2.x中将multi变为列表
    multi = [10]

    def create_y(x):
        # 可以对外层函数的列表进行修改
        multi[0] = 5
        print((k * x + b) * multi[0])

    return create_y


l1 = line(1, 3)
l1(4)
l1(5)
l1(6)

四、闭包和函数、对象等的区别

函数（包含匿名函数）：只是功能代码，不包含数据。

对象：包含数据和功能实现。

闭包：包含数据和功能实现。数据指外层函数接收到的参数以及他的局部变量，功能指内层函数的功能。

当函数、匿名函数、对象和闭包做为实参传递时，他们有什么区别？？？？

1.函数和匿名函数被当做实参传递时，传递的是功能的引用，可以通过该引用调用他们实现的功能。但数据需要另外提供。

2.闭包被当做实参传递时，其实传递了数据+功能。例如：

def line(k, b):
    # python2.x中将multi变为列表
    multi = [10]

    def create_y(x):
        # 可以对外层函数的列表进行修改
        multi[0] = 5
        print((k * x + b) * multi[0])

    return create_y


def function(func):
    func(5)


function(line(1, 3))

我们可以看到，闭包line被传入function，实际上带着数据k=1,b=3。

而如果是普通函数：

def line_norm(k, b, x):
    print(k * x + b)


def function(func):
    func(1, 3, 5)


function(line_norm)

这里的k=1,b=3是function函数自己提供的。

3.对象被当做实参传递时，该对象中的成员属性作为数据，成员方法作为方法，都被传递给function函数。

class Line(object):
    def __init__(self, k, b):
        self.k = k
        self.b = b

    def create_y(self, x):
        print(self.k * x + self.b)


line1 = Line(1, 3)


def function(inst):
    inst.create_y(5)


function(line1)