闭包
在我们使用返回函数的时候，由于我们在一个函数中需要返回另一个函数，因此，我们在这个函数中就需要重新定义一个函数。而这样，就造成了我们的函数嵌套问题。外面的函数相对于里面的函数而言是外函数（outer function），而里面的我们叫他内函数（inner function）。
|
1
2
3
4
5
6
7
|
def outerFunction(): #外函数
def innerFunction(): #内函数
x = 1
return x
return innerFunction #返回值是一个函数
a = outerFunction()
print(a)
|
这里我们打印 a 的值得时候，实际上打印的是我们的返回函数的地址 ：
<function outerFunction.<locals>.innerFunction at 0x0000019C278C0E50>
一般情况下，我们在使用函数作为返回值得时候，我们会在内函数中使用我们外函数中的变量，这种情况就会产生一个有意思的事情了。内函数会被返回给外部的其他调用者，而我们的变量是在我们的外函数中定义的。此时，我们的变量的作用域会发生怎样的变化呢？
测试：
|
1
2
3
4
5
6
7
|
def outerFunction(x): #外函数
y = 10
def innerFunction(): #内函数
return x + y
return innerFunction #返回值是一个函数
a = outerFunction(10)
print(a())
|
打印：
20
这里可以看到，我们的在给 a 赋值的时候，同时给外函数传进去了一个值10，然后，我们直接把 a() 打印出来，此时，我们的 a 返回了 20，说明我们的变量和参数在进入内函数后，我们的内函数会保留这个变量的值。
这里，我们把这种现象叫做“闭包（Closure）”，我试着多次返回这个内函数，看看他们的地址是否一致：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
def outerFunction(x): #外函数
y = 10
def innerFunction(): #内函数
return x + y
return innerFunction #返回值是一个函数
a = outerFunction(10)
b = outerFunction(20)
c = outerFunction(30)
print(a())
print(b())
print(c())
print(a)
print(b)
print(c)
|
打印：
20
30
40
<function outerFunction.<locals>.innerFunction at 0x0000020C480C0DC0>
<function outerFunction.<locals>.innerFunction at 0x0000020C480C0D30>
<function outerFunction.<locals>.innerFunction at 0x0000020C480CD280>
这里我们可以看到每个 innerFunction 的地址都不同，当我们多次调用返回函数的时候，每调用一次，我们的返回函数就会新创建一个函数给我们的变量。
那么，如果我们在外函数里面多次调用我们的内函数，我们的外函数的变量的作用域是什么样的呢？
我们测试一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
def outerFunction(x): #外函数
L=[] #定义一个List
y = 10
for i in range(1, 4):
def innerFunction(): #内函数
return (x + y) * i #使用我们外函数得变量
print(innerFunction()) #打印内函数返回得值
#print(innerFunction)
L.append(innerFunction) #把内函数添加到我们得List中
return L #返回这个List
a = outerFunction(10)
print(a[0])
print(a[1])
print(a[2])
print(a[0]())
print(a[1]())
print(a[2]())
|
看打印：
20
40
60
<function outerFunction.<locals>.innerFunction at 0x00000274AD6B0E50>
<function outerFunction.<locals>.innerFunction at 0x00000274AD6BD040>
<function outerFunction.<locals>.innerFunction at 0x00000274AD6BD3A0>
60
60
60
这里我们可以看到一个有意思得现象：
当我们在我们的函数内多次调用我们的内函数，并把它的返回值打印出来的时候，我们可以看到这个值是正常的（依次递增）。而如果我们把这个内函数传递到我们的 List 中，在函数外部调用它的时候，我们的函数的返回值全部变成了 60 也就是他们的只得到了我们外函数中变量的最终的值。这个就是我们的闭包特有的现象。
闭包中的变量
一般情况下，当一个函数结束的时候，在内存中，我们这个函数内部的局部变量会连同这个函数一起被释放掉。
但是，当我们这个函数包含闭包的时候，也就是说，当这个函数的返回值是一个函数的引用的时候。此时，当这个函数结束时，由于它内部的局部变量需要被释放掉，因此，它会把这个变量的值给传递给它所要返回的这个函数的内部。正是因为这样，当我们在外部调用我们的返回函数的时候，我们会看到它使用的变量全都是这个变量在函数内的最终的值，因为这个变量是这个外函数在结束的时候才传递给我们的返回函数的。而此时，我们函数内的变量只能有一个值。
但是，我们可以使用另一个办法来规避这种情况：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
def outerFunction(x): #外函数
L=[] #定义一个List
y = 10
def innerFunction(i): #内函数
def f():
return (x + y) * i #使用我们外函数得变量
return f
for i in range(1, 4):
print(innerFunction(i)()) #打印内函数中的内函数的返回值
L.append(innerFunction(i)) #把内函数添加到我们得List中
return L #返回这个List
a = outerFunction(10)
print(a[0])
print(a[1])
print(a[2])
print(a[0]())
print(a[1]())
print(a[2]())
|
打印如下：
20
40
60
<function outerFunction.<locals>.innerFunction.<locals>.f at 0x00000155B0F80040>
<function outerFunction.<locals>.innerFunction.<locals>.f at 0x00000155B0F803A0>
<function outerFunction.<locals>.innerFunction.<locals>.f at 0x00000155B0F80430>
20
40
60
这里我们可以看到我们在外部调用的时候，函数的返回值和在内部调用的返回值是一样的。那么我们分析一下这个函数的执行过程以及函数内的变量的作用域情况。
首先，我们在我们由于的内函数的基础又添加了一层内函数 f() ，并且，在这个内函数里面，我们使用了外部的内函数 innerFunction 的参数作为了返回值。然后，我们在 for 循环内部把我们的 innerFunction 这个函数的返回值添加进来我们的 List 里面。
这里我们应该已经发现了。在 for 循环内部，当我们把 innerFunction 的返回值 f 添加到我们的 List 中的时候，由于 innerFunction 相对于函数 f() 而言，f() 是属于 innerFunction 的内函数的，因此，当我们返回 f() 这个函数的时候，此时，f() 函数内部使用的值就是它的最终值了，而此时，我们的 innerFunction 函数还在 for 循环内部，因此，在循环内部，每次调用我们的 innerFunction 的返回值时，我们的传递到我们的 f() 函数中的值就是我们的最终值了。
此时，即使是我们在外部调用这个 f() 函数，它返回的值和内部调用时也是一样的。
以上就是Python编程中闭包的变量作用域问题解析的详细内容，更多关于Python闭包中变量作用域的资料请关注服务器之家其它相关文章！
原文链接：https://blog.csdn.net/qq_25827755/article/details/120859552