函数对象

 一：函数对象：函数是第一类对象，即函数可以当作数据传递
    1 可以被引用
    2 可以当作参数传递
    3 返回值可以是函数
    3 可以当作容器类型的元素
        #利用该特性，优雅的取代多分支的if
        def foo():
            print('foo')

        def bar():
            print('bar')

        dic={
            'foo':foo,
            'bar':bar,
        }
        while True:
            choice=input('>>: ').strip()
            if choice in dic:
                dic[choice]()

    二：函数的嵌套
        1 函数的嵌套调用
            def max(x,y):
                return x if x > y else y

            def max4(a,b,c,d):
                res1=max(a,b)
                res2=max(res1,c)
                res3=max(res2,d)
                return res3
            print(max4(1,2,3,4))

        2 函数的嵌套定义
            def f1():
                def f2():
                    def f3():
                        print('from f3')
                    f3()
                f2()

            f1()
            f3() #报错

def f():
    a=3
    def f1():
        a=1
        def f2(a):
            a=2
        f2(a)
        print('a in f1:',a)
    f(1)
    print('a in f :',a)
f()
print(l)

 

    三 名称空间和作用域：
        名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）
        加载顺序是？
        名字的查找顺序？（在全局无法查看局部的，在局部可以查看全局的）

        # max=1
        def f1():
            # max=2
            def f2():
                # max=3
                print(max)
            f2()
        f1()
        print(max)

        作用域即范围
　　　　   - 全局范围：全局存活，全局有效
　　　　   - 局部范围：临时存活，局部有效
          - 作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下

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

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

　　　　　　f3(f1())

        查看作用域：globals(),locals()

        global
        nonlocal


        LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
        locals 是函数内的名字空间，包括局部变量和形参
        enclosing 外部嵌套函数的名字空间（闭包中常见）
        globals 全局变量，函数定义所在模块的名字空间
        builtins 内置模块的名字空间



    四：闭包:内部函数包含对外部作用域而非全局作用域的引用
       提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇

        def counter():
            n=0
            def incr():
                nonlocal n
                x=n
                n+=1
                return x
            return incr

        c=counter()
        print(c())
        print(c())
        print(c())
        print(c.__closure__[0].cell_contents) #查看闭包的元素



    闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
    应用领域：延迟计算（原来我们是传参，现在我们是包起来）
    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'))