闭包学习-Python 篇

作为一个没有女朋友的码农,情人节这天只能敲敲代码,或者写写一些自己学习上的一些心得

下面我就说一说我学习“闭包” 这个结构时的一些问题和心得吧!

刚接触闭包的时候,感觉闭包很简单啊,在Python 中,不就是一个函数内再定义一个函数么,里面的函数用了外面函数的变量,这有什么难的?可随着不断的深入学习和研究,才发现了闭包结构的魅力。

首先学习闭包之前,你必须有一些Python 基础的了解,最重要的一点,就是函数名的概念,不了解的同学看下面这个例子:

def test1():
    print("in test1")

test1()          # in test1
f = test1
f()              # in test1

       分析一下,首先我们定义了一个函数 test1, 函数的作用就是打印一句话“in test1”,接着我们调用了一下这个函数,发现没有什么问题,能正常打印。

       接下来的就比较奇怪了,我们把test1 这个函数名赋值给了一个变量f (赋值这个词用的不是很恰当),然后对f 进行了函数调用,发现能打印出和调用test1 一样的内容,是不是很奇怪,我们并没有定义f 这个函数。对比以下小栗子,可能你就明白其中的原因了。

a = 10
b = a
print(b)          # 10

       第一行我们先创建了变量a,并把数值10 赋值给它,也就是数值10 的引用加一, 然后第二行是把变量a 赋值给了变量b,Python 中的赋值就是引用的传递 ,也就是将变量a 引用的内容 传递给了变量b,此时数值10 的引用再次加一,所以会有了第三行的结果,我们并没有直接把数值10 赋值给变量b,而是通过变量a 的引用传递,使得变量b 也被赋值了10.

        说了那么多,大家有没有发现什么问题?没错,函数名test1 不就相当于 变量a 吗? f 不就相当于变量b 吗?不同的是 test1 引用的是一个函数代码空间,而a 引用的是一个整数10,那么是不是就可以说函数和变量名一样,可以把它引用的代码空间传递给其他变量名? 当然是这样的,如果不成立的话,可能就不会有类似闭包这个结构了。

接下来,我们再根据下面的例子,来继续学习闭包

def outer(number_out):
    def inner(number_in):
        return number_out + number_in
    return inner

f1 = outer(100)
f2 = outer(100)
print(f1)          # <function outer.<locals>.inner at 0x000002102F5E02F0>
print(id(f1))          # 2268537422576
print(id(f2))          # 2268537422440

  分析f1 = outer(100) ,这个100 其实就是number_out 的实参,并且调用返回了 inner 这个函数名,结果为 f1 = inner,通过引用传递,将内部定义的函数 inner所引用的函数代码块,传递给了f1,此时f1 是一个 函数对象,但为什么使用相同函数调用,传入的实参也一样,两个对象却不一样?这是因为f1 = inner 的这个结果,是只有在调用outer(number_out) 的时候才去定义的inner 这个函数,作用域不同,也就不会是相同的inner 了,这也就是闭包的魅力之一了,此时调用f1(number_in) 和调用f2(numberi_in) 之间互不影响。 

如果觉得上面的例子还算简单,那么再看一下稍微复杂一点的例子:

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

line1 = line_conf(1, 2)
line2 = line_conf(3, 3)
print(line1(3))          # 5
print(line2(3))          # 12

  上面这个闭包的例子,函数line 和 变量a,b 构成闭包,通过确定line_conf 的参数a,b,转换成实际的函数就是,line1 :y = x + 2,line2:y = 3x + 3,所以我们只需要变换参数a,b 的值,就能得到不同的一次函数表达式,如果没有闭包结构,每次都要传递a, b, x 三个参数,减少了代码的可移植性,由此可以看出,闭包结构具有提高代码复用性的作用

注意:由于闭包引用了外层函数的局部变量,则外层函数的局部变量没有及时释放,消耗内存

 

总结:

      闭包结构就是一个嵌套定义的函数,在外层函数开始的时候才开始定义内层函数的定义,然后将内层函数代码块的引用传递给函数外的对象

      内层函数和使用外层函数的提供的变量所构成的整体就被称为闭包

 

扩展:闭包结构中,修改外层函数局部变量的方法

Python 2

def counter(start=0):
    count = [start]
    def inner():
        count[0] += 1
        return count[0]
    return inner


f1 = counter()
f2 = counter()

print(f1())          # 1
print(f1())          # 2
print(f2())          # 1
print(f2())          # 2

  由此也可以看出,f1 和f2 确实是互不影响的两个对象.

 

Python 3 

def counter(start=0):
    def inner():
        nonlocal start
        start += 1
        return start 
    return inner

f1 = counter()
f2 = counter()

print(f1())          # 1
print(f1())          # 2
print(f2())          # 1
print(f2())          # 2

  

 

猜你喜欢

转载自www.cnblogs.com/yungiu/p/10374046.html
0条评论
添加一条新回复