理解Python中的闭包
2021-07-12 10:07
标签：javascrip count() print 函数式 数据 循环 因此 iss range 闭包是函数式编程的一个重要的语法结构，函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中，我们见到过函数(function)；在面向对象编程中，我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。 结合这段简单的代码和定义来说明闭包： 再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，inner就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。 在函数outer中定义了一个inner函数，inner函数访问外部函数outer的（参数）变量，并且把inner函数作为返回值返回给outer函数。 上面的代码中a就是一个函数，代码的执行结果为： 从结果我们不难看出，a是函数inner而不是outer，这个有点绕，但是并不难理解，因为return回来的是inner函数。 输出结果为： 调用函数a，得到的结果是传入参数的值相加。 上面的和这句是一样的： 如果innerFunc可以修改x的值的话，x的值前后会发生变化，但结果是： 在innerFunc中x的值发生了改变，但是在outerFunc中x的值并未发生变化。 再来看一个例子 运行会报错： 解决的方法： 2.python3通过nonlocal关键字来解决，该语句显式的指定a不是闭包的局部变量。 还有一个容易产生错误的事例也经常被人在介绍python闭包时提起，我一直都没觉得这个错误和闭包有什么太大的关系，但是它倒是的确是在python函数式编程是容易犯的一个错误，我在这里也不妨介绍一下。先看下面这段代码 在程序里面经常会出现这类的循环语句，Python的问题就在于，当循环结束以后，循环体中的临时变量i不会销毁，而是继续存在于执行环境中。还有一个python的现象是，python的函数只有在执行时，才会去找函数体里的变量的值。 可能有些人认为这段代码的执行结果应该是2,3,4.但是实际的结果是4,4,4。loop在python中是没有域的概念的，flist在像列表中添加func的时候，并没有保存i的值，而是当执行f(2)的时候才去取，这时候循环已经结束，i的值是2，所以结果都是4。 解决方法也很简单，改写一下函数的定义就可以了。 另外一个例子： 需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了 在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都添加到一个 你可能认为调用 全部都是 返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。 如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变： 注意这里用了一个“创建一个匿名函数并立刻执行”的语法： 理论上讲，创建一个匿名函数并立刻执行可以这么写： 但是由于JavaScript语法解析的问题，会报SyntaxError错误，因此需要用括号把整个函数定义括起来： 通常，一个立即执行的匿名函数可以把函数体拆开，一般这么写： 说了这么多，不免有人要问，那这个闭包在实际的开发中有什么用呢？闭包主要是在函数式开发过程中使用。以下介绍两种闭包主要的用途。 比如说，如果你希望函数的每次执行结果，都是基于这个函数上次的运行结果。我以一个类似棋盘游戏的例子来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向(direction)，步长(step)，该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外，当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标。 输出为： 这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行。 如果我们需要取得文件”result.txt”中含有”pass”关键字的行，则可以这样使用例子程序 以上两种使用场景，用面向对象也是可以很简单的实现的，但是在用Python进行函数式编程时，闭包对数据的持久化以及按配置产生不同的功能，是很有帮助的。 理解Python中的闭包 标签：javascrip count() print 函数式 数据 循环 因此 iss range 原文地址：https://www.cnblogs.com/muchengnanfeng/p/9547329.html1.定义
不同编程语言实现闭包的方式是不同的，python中闭包从表现形式上看，如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)。
举个例子：1 def outer(x):
2 def inner(y):
3 return x + y
4 return inner
inner(y)就是这个内部函数，对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域outer里面，但不在全局作用域里，则这个内部函数inner就是一个闭包。1 a = outer(2)
2 print(‘function:‘,a)
3 print(‘result:‘,a(3))
1 print(‘a.func_name‘,a.func_name)
print(‘result:‘,outer(2)(3))2.使用闭包注意的地方
2.1闭包无法修改外部函数的局部变量
2.2闭包无法直接访问外部函数的局部变量
1 def outer():
2 x = 5
3 def inner(): #上面一行的x相对inner函数来说是函数外的局部变量（非全局变量）
4 x *= x
5 return x
6 return inner
7
8 outer()()
1.在python3之前没有直接的解决方法，只能间接地通过容器类型来解决，因为容器类型不是存放在栈空间的，inner函数可以访问到。1 def outer():
2 x = [5]
3 def inner():
4 x[0] *= x[0]
5 return x[0]
6 return inner
7
8 print(outer()()) #25
1 def outer():
2 x = 5
3 def inner():
4 nonlocal x #把x声明为非局部变量
5 x *= x
6 return x
7 return inner
8
9 print(outer()())
2.3python循环中不包含域的概念
1 for i in range(3):
2 print i
1 flist = []
2 for i in range(3):
3 def foo(x): print x + i
4 flist.append(foo)
5 for f in flist:
6 f(2)
for i in range(3):
def foo(x,y=i): print x + y
flist.append(foo)
f()才执行。我们来看一个例子： 1 function count() {
2 var arr = [];
3 for (var i=1; i) {
4 arr.push(function () {
5 return i * i;
6 });
7 }
8 return arr;
9 }
10
11 var results = count();
12 var f1 = results[0];
13 var f2 = results[1];
14 var f3 = results[2];
Array中返回了。f1()，f2()和f3()结果应该是1，4，9，但实际结果是：1 f1(); // 16
2 f2(); // 16
3 f3(); // 16
16！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了4，因此最终结果为16。 1 function count() {
2 var arr = [];
3 for (var i=1; i) {
4 arr.push((function (n) {
5 return function () {
6 return n * n;
7 }
8 })(i));
9 }
10 return arr;
11 }
12
13 var results = count();
14 var f1 = results[0];
15 var f2 = results[1];
16 var f3 = results[2];
17
18 f1(); // 1
19 f2(); // 4
20 f3(); // 9
1 (function (x) {
2 return x * x;
3 })(3); // 9
1 function (x) { return x * x } (3);
1 (function (x) { return x * x }) (3);
1 (function (x) {
2 return x * x;
3 })(3);
3.闭包的作用
用途1：当闭包执行完后，仍然能够保持住当前的运行环境。
1 origin = [0, 0]
2 legal_x = [0, 50]
3 legal_y = [0, 50]
4 def create(pos=origin):
5 def player(direction,step):
6 # 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等
7 # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。
8 new_x = pos[0] + direction[0]*step
9 new_y = pos[1] + direction[1]*step
10 pos[0] = new_x
11 pos[1] = new_y
12 #注意！此处不能写成 pos = [new_x, new_y]，因为参数变量不能被修改，而pos[]是容器类的解决方法
13 return pos
14 return player
15
16 player = create() # 创建棋子player，起点为原点
17 print player([1,0],10) # 向x轴正方向移动10步
18 print player([0,1],20) # 向y轴正方向移动20步
19 print player([-1,0],10) # 向x轴负方向移动10步
1 [10, 0]
2 [10, 20]
3 [0, 20]
用途2：闭包可以根据外部作用域的局部变量来得到不同的结果
1 def make_filter(keep):
2 def the_filter(file_name):
3 file = open(file_name)
4 lines = file.readlines()
5 file.close()
6 filter_doc = [i for i in lines if keep in i]
7 return filter_doc
8 return the_filter
1 filter = make_filter("pass") filter_result = filter("result.txt")
上一篇：c++ queue
下一篇：JavaScript模拟自由落体