函数进阶

Python内部的原理：

　　从Python解释器开始执行之后，就在内存中开辟一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。

　　等执行到函数调用的时候，Python解释器会在开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

　　命名空间：存放名字与值得关系的空间

　　代码在运行伊始，创建的存储“变量名与值得关系”的空间叫全局命名空间。

　　在函数的运行中开辟的临时的空间叫做局部命名空间

命名空间与作用域

命名空间一共三种：

　　全局命名空间、

　　局部命名空间、

　　内置命名空间

内置命名空间中存放了Python解释器为我们提供的名字：比如说Input、print、str、list等。

三种命名空间之间的加载与取值顺序：

加载顺序：

　　内置命名空间（程序运行前加载）-> 全局命名空间（程序运行中，从上到下加载）-> 局部命名空间（程序运行中：调用才加载）

取值顺序：

　　在局部调用：局部命名空间 -> 全局命名空间 -> 内置命名空间

　　在全局调用：全局命名空间 -> 内置命名空间

综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。

作用域

　　作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

　　全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用，全局有效。

　　局部作用域：局部名称空间，只能在局部范围内生效

globals和locals方法：

b = 10
def func():
    a = 10
    print(globals()) #打印全局作⽤用域中的内容
    print(locals()) # {'a': 10} 打印局部作用域中的内容
    print(a)
func()

global，nonlocal关键字

　　1、声明一个全局变量

　　2、在局部作用域想要对全局作用域的全局变量进行修改时，需要用到global（限于字符串、数字）

a = 10
def func():
    global a
    a = 20
    print('局部变量中的：%d'%a) # 20
func()
print('全局变量中的：%d'%a) # 20

对于可变数据类型，可以直接引用不用通过global

nonlocal:

　　1、不能修改全局变量

　　2、在局部作用域中，对父级作用域（即更外一层作用域并非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。

a = 10
def func():
    a = 20
    def fun():
        nonlocal a
        a = 30
        print('fun函数中的为：%d'%a) # 30
    fun()
    print('func函数中的为：%d' %a) # 30
func()
print('全局变量中的：%d'%a) # 20

函数名的本质：

函数名实质上就是函数的内存地址

def han_1():
    print('函数1')
print(han_1) # <function han_1 at 0x1038f38c8> 函数名的地址

def han_2():
    print('函数2')

1、函数名可以像变量一样赋值

print(han_1) # <function han_1 at 0x1038f38c8> 函数名的地址
fu = han_1 # 传递地址
fu() # 调用函数

2、函数可以作为容器类型的元素：

lis = [han_1,han_2] #不带括号是地址
lis = [han_1(),han_2()] # 带括号的是返回值

3、函数可以作为返回值返回

def han_3():
    def func():
        print('func')
    return func
fu = han_3() #返回值为func
fu() #相当于调用func()函数

4、函数可以作为参数进行传递

def func_1(fuc):
    fuc()

def fu():
    print('123')

func_1(fu) # 打印'123' 将函数名作为参数传递

第一类对象（first-class Object）指：

1、可在运行期间创建

2、可用作函数参数或返回值

3、可存入变量的实体

闭包

    目的：让内存永远记住一个变量
    定义：在内层函数中访问外层函数的局部变量
    外层的这个局部变量将会常住内存

def func():
    a = 10
    def inner():
        print(a) #内层函数中访问外层函数的局部变量
    inner()
    # 使用函数名.__closure__检查函数是不是闭包 ，返回None就不是
    print(inner.__closure__) # (<cell at 0x1040b22e8: int object at 0x1009cce20>,) 这个就是
func()

# 函数名带括号返回的是函数的返回值
# 不带括号返回的是函数的地址
# 例如：
def  func():
    print('123')
print(func()) # None
print(func)  # <function func at 0x1039028c8>

#闭包嵌套
def wrapper():
    money = 1000
    def func():
        name = 'eva'
        def inner():
            print(name,money)
        return inner
    return func
f = wrapper() # func
i = f() # inner
i() #调用inner