《零基础入门学习python》第二十讲笔记：函数：内嵌函数和闭包

bozhen

global关键字; 在函数里面定义一个global 变量，使之变成全局变量

内嵌函数：在函数内部创建另一个函数

1. >>> def fun1():
   
2.             print('fun1()正在被调用。。。')
   
3.             def fun2():   #函数嵌套
   
4.                  print('fun2()正在被调用。。。')
   
5.             fun2()
   
6. 
   
7. 
   
8. >>> fun1()  # 执行的过程是先走到def fun1(),print('fun1()正在被调用。。 '),然后到fun2(),然后再到def fun2(),print('fun2()正在被调用。。。 ')
   
9. fun1()正在被调用。。。
   
10. fun2()正在被调用。。。
    
11. >>>
    
12. 
    
13. >>> fun2()
    
14. Traceback (most recent call last):
    
15.   File "<pyshell#12>", line 1, in <module>
    
16.     fun2()
    
17. NameError: name 'fun2' is not defined

复制代码

上面这个例子。只有fun1()能调用fun2(),出了fun1(),没人能调用得到fun2()

闭包：如果在一个内部函数里引用外部作用域的变量，那么这个内部函数就称为闭包

1. >>> def funx(x):
   
2.              def funy(y):
   
3.                   return x * y
   
4.              return funy    #python所有东西都是对象，可以返回函数对象
   
5. 
   
6. >>> i = funx(8)  # 调用funx(),并给实参8，然后赋值给i
   
7. >>> i
   
8. <function funy at 0x000000000324AEC8>
   
9. >>> type(i)   #  i 是一个函数，因为funx()返回的是一个函数
   
10. <class 'function'>
    
11. >>> i(5)    # 给y的参数设为5
    
12. 40
    
13. >>> funx(8)(5)   # 或者直接两个括号分别传实参
    
14. 40
    
15. >>> funy(5)  # 在全局调用内部函数会报错
    
16. Traceback (most recent call last):
    
17.   File "<pyshell#20>", line 1, in <module>
    
18.     funy(5)
    
19. NameError: name 'funy' is not defined

复制代码

在闭包中，外部函数的变量相对内部函数的变量，相当于全局变量和局域变量的关系。在内部函数，只能访问外部函数变量而不能修改

1. >>> def fun1():
   
2.              x = 5
   
3.              def fun2():
   
4.                  x *= x     # 这里fun2函数里修改fun()函数里x变量的值，是不允许的，只能访问
   
5.                  return x
   
6.           return fun2()
   
7. 
   
8. >>> fun1()
   
9. Traceback (most recent call last):
   
10.   File "<pyshell#28>", line 1, in <module>
    
11.     fun1()
    
12.   File "<pyshell#27>", line 6, in fun1
    
13.     return fun2()
    
14.   File "<pyshell#27>", line 4, in fun2
    
15.     x *= x
    
16. UnboundLocalError: local variable 'x' referenced before assignment
    
17. >>>
    
18. >>> def fun1():
    
19.              x = [5]  # 把x换成列表类型，因为列表不存放在栈里面，数据不会被清空，这只是一个临时的投机取巧方法
    
20.              def fun2():
    
21.                  x[0] *= x[0]
    
22.                  return x[0]
    
23.              return fun2()
    
24. 
    
25. >>> fun1()
    
26. 25
    
27. >>> def fun1():
    
28.     x = 5
    
29.     def fun2():
    
30.         nonlocal x    #把外部函数变量x 在内部函数里定义成nonlocal,这样就能修改外部函数x的值了
    
31.         x *= x
    
32.         return x
    
33.     return fun2()
    
34. 
    
35. >>> fun1()
    
36. 25
    

复制代码

总结：在内部函数定义了nonlocal 变量，然后将此变量重新赋值。 拿到全局去，此值仍然有效。
          funx() 是一个函数，但funx 和 funx() 最大区别是后者会走到def funx()那里去，而前者不会，前者作为return的话，返回的就是一个函数对象。
          如果在函数中修改全局变量的值，需先用global 定义一下这个变量，如果想在内部函数修改外部函数的值，应使用nonlocal定义一下这个变量