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

1、命名空间概念

一、命名空间（name space）

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

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

二、名称空间加载顺序

python test.py
#一、python解释器先启动，于是首先加载的是：内置名称空间
#二、执行test.py文件，而后以文件为基础，加载全局名称空间
#三、在执行文件的过程当中若是调用函数，则临时产生局部名称空间

三、名字的查找顺序

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

　　须要注意的是：在全局没法查看局部的，在局部能够查看全局的，以下例：

# 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
"""

2、做用域　　

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

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

一、做用域即范围

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

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

x=1
def f1():
    def f2():
        print(x)
    return f2

x=100
def f3(func):
    x=2
    func()

x=10000
f3(f1())
"""
10000
"""

三、查看做用域

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

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

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

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'}

　　输出以下结果：

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

3、闭包函数

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

一、什么是闭包？

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

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

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

　　在外部能够执行内部的函数，而且可使用内部函数做用域里的值，这种现象就是闭包。

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

二、闭包的意义和应用

　　闭包的意义：返回的函数对象，不只仅是一个函数对象，在该函数外还包裹了一层做用域，这使得，该函数不管在何处调用，优先使用本身外层包裹的做用域。

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

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'))

4、函数嵌套返回值

age = 18
def func1():
    age = 73
    def func2():
        age = 84
        print(age)

    return 666

val = func1()
print(val)
'''
输出：666
'''

 函数能够当作返回值：

# 函数名能够看成返回值
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
'''