day12 函数嵌套

def index(a,b,c):
    print(a,b,c)

def wrapper(*args,**kwargs):  # args=(1,2,3)    kwargs={}
    index(*args,**kwargs)  # index(*(1,2,3) ,**{})  # index(1,2,3)

wrapper(b=2,c=3,a=1)


一、函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数
# 函数的嵌套定义: 在函数内又定义了一个函数
# def f1():  # 定义在函数内部的内容有一个效果：函数外无法访问，只有在函数内才可以访问到
    from math import pi
    def circle(radius,mode=0):
         def perimiter(radius):
            return 2 * pi * radius

        def area(radius):
             return pi * (radius ** 2)

         if mode == 0:
             return perimiter(radius)
         elif mode == 1:
             return area(radius)
    circle(3,0)


def foo():  # foo->函数的内存地址
    print('from foo')

x = 10  # x->10的内存地址

1、可以被赋值
    y = x
    f = foo
    f()

2、可以当做参数传入
    def f1(func):
         print('====>f1')
        func()

    f1(foo)  # f1(函数的内存地址)

3、可以当做返回值
    def f1(func):
        return func

    f = f1(foo)
    print(f)

4、可以当做容器类型的元素
    x = 10
    l = [x,foo,foo()]
    print(l)
    l[1]()


名称空间Namespace：存放名字与内存地址绑定关系的地方
# 名称空间分三种：
    1、内置名称空间：存放python解释器自带的名字
        print(len)
        print(input)

    2、全局名称空间: 存放的是顶级的名字，如下x、z、f1、xxx都是
        x = 100
        def f1():
            y = 200

        if 10 > 3:
            z = 300

            if True:
                xxx = 400

    3、局部名称空间：存放的是函数内定义的名字
        def f1():
            x = 200

        f1()

# 重要结论1：局部Local-》外层函数Enclosing-》全局Global-》内置Builtin
                #  L->E->G->B

例1：
    def f1():
        # len = 200
        print(len)

    len = 100   # 全局顶级代码

    f1()

    print('=====>',len)

例2：LEGB
    len = 100
    def f1():
        # len = 200

        def f2():
            # len = 300
            print(len)
        len = 1111111111111111111111111111111111111111111
        f2()

    f1()
# 重要结论2：名称空间的嵌套关系是在函数定义阶段、扫描语法时就确定好的，与调用位置无关

例1：
    len = 100
    def f1():
        # len = 200
        def f2():
            print(len)

        return f2

    f = f1()

    # print(f)

    len = 6666666666666
    f()

例2：
    len = 100
    def f1():
        def f2():
            print(len)
        # len = 200

        return f2

    f = f1()

    def foo():
        len = 77777
        f()

    foo()

例3
    x = 100

    def f1():
        print(x)
        x = 200

    f1()

# 总结：
    全局作用域：全局存活，全局有效
              内置名字空间、全局名称空间

    局部作用域：临时存活，局部有效
              局部名称空间

=============》 global关键字
l = []
x = 100

def foo():
    l.append(333)

    global x
    x = 200

foo()

print(l)
print(x)

=============》 nonlocal关键字


闭函数：定义在函数内部的函数
    def outter():
        def wrapper():
        print('====>wrapper')

包函数: 内部函数引用了一个来自于外层函数的变量
    def outter():
        x = 111
        def wrapper():
            print('====>wrapper',x)