"""

# 函数进阶

命名空间和作用域

命名空间

全局命名空间——我们自己写的非函数中的代码

    是在程序从上到下被执行的过程中依次加载进内存的，

    放置了我们设置的所有的变量名和函数名，

局部命名空间，——函数

    就是函数内部定义的名字

    在函数调用的时候才会产生这个命名空间，随着函数调用的结束，这个命名空间就消失了，

内置命名空间，——Python解释器，

    就是Python解释器一启动就可以使用的名字，存储在内置的命名空间中，比如print，input，list等，

    内置的名字，在启动解释器的时候就会加载进去内存中，

在全局我们可以使用内置的明明靠空间，但是不能使用局部的，

在局部我们可以使用全局的，内置的命名空间，

在内置的里面不能使用全局的和局部的，

所以就像是一个套娃一样，最外层是内置的，然后是全局的，然后是局部的，

如果我们定义在全局定义了和内置的函数同名的名字，会使用全局的，

"""

def input():

    print(123)

def func():

    # input=1

    print(input)

func()

"""

作用域

作用域和命名空间是分不开的，

作用域有两种，

1，全局作用域，内置和全局的命名空间，都是全局作用域，

2，局部作用域，我们现在就知道一个局部，就是函数，

对于不可变类型，你可以在局部查看全局的变量，但是不能修改，如果要修改，你就需要使用global进行声明，

自己的代码中应该尽量少使用global，这样会导致代码非常不安全，混乱，

"""

a =1

# def func():

#     global a

#     a += 1

# func()

# print(a)

def func(a):

    a += 1

    return a

# 不使用global，可以使用另一种方法

a = func(a)

print(a)  # 2

"""

globals

locals

"""

a =1

b = 2

def func():

    x = "aaa"

    y = "bbb"

    print(locals())  # 会打印出所有的局部变量的名字和值，  {'y': 'bbb', 'x': 'aaa'}

    print(globals())  # 这个还是全局的，

func()

print(globals())  # 会打印出所有全局的名字，和内置的变量的名字，然后是函数名，

print(locals())  # print(globals()),这个打印出的本地和全局是一样的，

# 函数的嵌套调用

# 两个数判断最大值

def max(a,b):

    return a if a>b else b  # 三元运算，a大于b，就是a，否则就是b，

# 三个数判断最大值，先判断两个，然后再判断和第三个，

def the_max(x,y,z):

    c = max(x,y)  # 这就是函数的嵌套调用，

    return max(c,z)

# 函数的嵌套定义，

# nonlocal 找离当前函数最近的一个局部变量，只会影响最近的一层，不能是全局变量，

def outer():

    a = 1

    def innner():

        print(123,)

        def innner2():

            nonlocal a

            a += 1

            print(a)

        innner2()

    innner()  # 一定要有这一句，否则内部定义的函数，不会生效，

outer()

# 函数名就是一个内存地址，

# 1，函数名可以赋值

# 2，函数名可以作为容器类型的元素，

# 3，函数可以作为参数调用，# 函数可以作为参数调用，

def func1():

    print(123)

func2=func1  # 函数名可以赋值

func2()

list1=[func1,func2]  # 函数名可以作为容器类型的元素，

def func3(func1):  # 函数可以作为参数调用，

    func1()

    return func1  # 函数名可以作为函数的返回值，

# 闭包

def outer():

    a = 1

    def inner():

        print(a)

    print(inner.__closure__)  # 这个inner函数就是一个闭包函数

    inner()

outer()

outer()

outer()

"""

(<cell at 0x0000000009C7BF78: int object at 0x000000005AA560A0>,)

1

(<cell at 0x0000000009C7BF78: int object at 0x000000005AA560A0>,)

1

(<cell at 0x0000000009C7BF78: int object at 0x000000005AA560A0>,)

1

"""

# 这种是闭包，但是这种写法比较浪费资源，每次都要生成a变量，

# 闭包的定义，就是一个嵌套函数，并且内部函数调用外部函数的变量，如果你没有调用外部函数的变量，就不是一个闭包，

# 所以闭包至少是两个条件，1是嵌套函数，2是内部的函数要使用到外部函数的变量，

# 优化这种写法：

def outer():

    a = 1

    def inner():

        print(a)

    print(inner.__closure__)  # (<cell at 0x0000000009C68FA8: int object at 0x000000005EA960A0>,)，有cell就是一个闭包，

    return inner  # 在外部函数中返回内部函数的名字，这就是一个闭包最常用的方式，

# 闭包最常用的形式是在外部函数中返回内部函数，

inn = outer()   # (<cell at 0x0000000009C7BF78: int object at 0x000000005A6B60A0>,)

inn()  #

inn()  #

inn()  #

inn()  # 1 # 这种写法我调用这个函数100次，但是里面的a变量就只会生成一次了，不会反复生成了，节省资源，

"""

(<cell at 0x000000000B90BF78: int object at 0x000000005AA560A0>,)

1

1

1

1

"""