19 - 函数：内嵌函数和闭包 - 景命

景命

知识点：
这一节的内容比较多大家要多看代码，最好能自己敲一遍。



global关键字：
        在函数内部用global关键字，可以修改全局变量的值。

1. >>> a = 10
   
2. >>> def b():
   
3.         global a
   
4.         a = 5
   
5.         print(a)
   
6. 
   
7. >>> b()                #调用函数b()
   
8. 5                        #返回值为已经改变的a的值5
   
9. >>> a                #输出全局变量a
   
10. 5                        #此时全局变量a的值已经发生改变

复制代码

内嵌函数（内部函数）：

1. def a():                        #定义函数a()
   
2.         print("函数a()正在被调用")
   
3.         def b():                #在函数a()中定义函数b()
   
4.                 print("函数b()正在被调用")
   
5.         b();                        #在函数a()中调用函数b().
   
6. 
   
7. a()                                #调用函数a()
   
8. 函数a()正在被调用        #输出函数a()里的语句，再输出函数b()里的语句。
   
9. 函数b()正在被调用

复制代码

注意：函数b()在函数a()内部定义，所以函数b()的作用域只在函数a()中，如果在函数a()外部调用函数b()将会报错。







闭包（claeune）：
不同的编程语言实现闭包的方式不同，Python中闭包从表现形式定义为，如果在一个内部函数里，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就会被认为是闭包。
例：

1. def a(x):                                #定义函数a()
   
2.         def b(y):                        #在函数a()中定义函数b()
   
3.                 return x * y        #在函数b()中引用其外部作用域变量x
   
4.         return b                        #函数a()的返回值为函数b()。在Python中函数属于对象，可以用return返回。
   
5. 
   
6. i = a(4)                                #调用函数a()，并将参数4传入，用变量i接受函数a()的返回值
   
7. type(i)                                #查看变量i的类型
   
8. <class 'function'>                #显示类型为函数
   
9. i(8)                                        #此时i为函数a()的返回值，也就是函数b()。
   
10. 32                                        #输出函数b()的返回值。
    
11. 
    
12. a(3)(4)                                #也可以用这种方式来调用函数a()，和函数a()内的函数b()，这种方式是访问函数中的函数。                       
    
13. 12                                          

复制代码

在闭包中外部函数的局部变量对内部函数的局部变量，就类似与全局变量与局部变量的关系。在内部函数中只能对外部函数的局部变量进行访问，但是不可以对外部函数的局部变量修改。
例：

1. def a():                               
   
2.         x = 3                                #定义外部函数的局部变量。
   
3.         def b():
   
4.                 x *= x                #在这里试图改变外部函数的局部变量
   
5.                 return x
   
6.         return b()                        #返回函数b()的返回值。(这样就会运行函数b内部的代码)
   
7. 
   
8. a()                #调用函数a()
   
9. UnboundLocalError: local variable 'x' referenced before assignment        #会报错

复制代码

但是用容器类型的变量（元组，列表）可以避免以上错误：

1. def a():
   
2.         x = [3]                        #将3存放在列表型变量x中
   
3.         def b():
   
4.                 x[0] *= x[0]        #将列表中的元素相乘
   
5.                 return x[0]        #返回的也是列表中的元素
   
6.         return b()
   
7. a()                                        #调用函数a()
   
8. 9                                        #返回值为9

复制代码

nonlocal关键字（与global关键字类似）：

1. def a():
   
2.         x = 3
   
3.         def b():
   
4.                 nonlocal x        #用nonlocal关键字来修饰变量x，x就可以被内部函数修改。
   
5.                 x *= x
   
6.                 return x
   
7.         return b()
   
8. a()
   
9. 9

复制代码