python函数名称空间与作用域、闭包

一、命名空间概念

1、命名空间（name space）

　　名称空间是存放名字的地方。

　　若变量x=1，1存放在内存中，命名空间是存放名字x、x与1绑定关系的地方。

2、名称空间加载顺序

?

1 2 3 4

python test.py #1、python解释器先启动，因而首先加载的是：内置名称空间 #2、执行test.py文件，然后以文件为基础，加载全局名称空间 #3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

3、名字的查找顺序

　　局部名称空间——》全局名称空间——》内置名称空间

　　需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下例：

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# max=1 def f1():     # max=2     def f2():         max=3         print(max)     f2() f1() print(max) """ 3 <built-in function max> """   max=1 def f1():     # max=2     def f2():         # max=3         print(max)     f2() f1() print(max) """ 1 1 """

二、作用域　　

　　python中一个函数就是一个作用域，局部变量放置在其作用域中；代码定义完成后，作用域已经完成，作用域链向上查找。类似C#、Java中作用域｛｝。

　　不同变量的作用域不同就是由这个变量所在的命名空间决定的。

1、作用域即范围

　　全局范围(内置名称空间与全局名称空间属于该范围)：全局存活，全局有效
　　局部范围(局部名称空间属于该范围)：临时存活，局部有效

2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

x=1 def f1():     def f2():         print(x)     return f2   x=100 def f3(func):     x=2     func()   x=10000 f3(f1()) """ 10000 """

3、查看作用域

LEGB 代表名字查找顺序：locals ——>enclosing(相邻的上一级) ——>globals ——> __builtins__

• locals 是函数内的名字空间，包括局部变量和形参
• enclosing 外部嵌套函数的名字空间
• globals 全局变量，函数定义所在模块的名字空间
• builtins 内置模块的名字空间

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

n = 10 def fun1():     n = 20     print('func1',n)       def fun2():         n = 30         print('func2',n)           def func3():             print("func3",n)    # locals没有，先找相邻上一级作用域         func3()  # 30     fun2()  # 30  fun1()  # 20

 　　依次输出：func1 20  ；func2 30  ； func3 30

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

def func():     level = 'L1'     n = 33     print(locals())       def outer():         n = 44         level = 'L2'         print(locals(), n)           def inner():             level = 'L3'             print(locals(), n)           inner()  # {'n': 44, 'level': 'L3'} 44       outer()  # {'n': 44, 'level': 'L2'} 44     func()  # {'n': 33, 'level': 'L1'}

　　输出如下结果：

?

1 2 3

{'n': 33, 'level': 'L1'} {'level': 'L2', 'n': 44} 44 {'level': 'L3', 'n': 44} 44

三、闭包函数

　　内部函数包含对外部作用域而非全局作用域的引用。之前都是通过参数将外部的值传给函数，闭包提供的思路是将参数包起来。

1、什么是闭包？

　　闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。

　　也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响。

?

1 2 3 4 5 6 7 8 9 10

def func():     n = 10       def func2():         print("func2:",n)  # 对外部作用域的引用     return func2   f = func()  # 拿到func2内存地址 print(f)  # func2内存地址：<function func.<locals>.func2 at 0x101fb4620> f()   # 执行func2: 10

　　在外部可以执行内部的函数，并且可以使用内部函数作用域里的值，这种现象就是闭包。

　　在函数里面套了一层子函数，在外层函数被执行的时候，子函数被返回了，返回的是内存地址，在外面执行子函数的时候用引用了外层函数的变量，相当于两者有一种扯不掉理还乱的关系。

2、闭包的意义和应用

　　闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。

　　应用领域：延迟计算（原来我们是传参，现在是抱起来）、装饰器

?

1 2 3 4 5 6 7 8 9 10 11

from urllib.request import urlopen   def index(url):     def get():         return urlopen(url).read()       return get     baidu = index('http://www.baidu.com') print(baidu().decode('utf-8'))

四、函数嵌套返回值

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

age = 18 def func1():     age = 73     def func2():         age = 84         print(age)       return 666   val = func1() print(val) ''' 输出：666 '''

 函数可以当做返回值：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# 函数名可以当作返回值 age = 18 def func1():     age = 73     def func2():...     return func2   # 返回一个函数名# val = func1() print(val) ''' 输出：<function func1.<locals>.func2 at 0x101462598> '''   # 代码写完之后作用域已经生成，不管函数名传到哪里，只要执行都回回定义的地方往上找 age = 18 def func1():     age = 73     def func2():         print(age)     return func2   # 返回一个函数名不带括号   val = func1() val() ''' 输出结果：73 '''