Python LEGB (Local, Enclosing, Global, Build in) 规则

　　　　  
　　　　　　 Local      一个函数定义了一个 local 作用域; PyFrameObject 中的 f_local 属性
        Global     一个 module 定义了一个 global 作用域; PyFrameObject 中的 f_global 属性.
        BuiltIn    open, dir 的作用域等等, python 最顶层的作用域
        Enclosing
            例子,
                b = 2
                def funcO():
                    b = 3
                    def funcI():
                        print(b)
                    return funcI

                f = funcO()
                f()                         #1

                Output,
                        3                   #1

                例子的输出结果是 '3' 而不是代码块儿最外层所定义的 'b = 2'.
                f() 实际调用的内嵌在 funcO 中的 funcI 函数. funcI 位于 funcO 之内, 所以函数 funcI 的作用域内嵌于函数 funcO 的作用域内.
                即, 函数 funcO 的作用域是内嵌函数 funcI 的'直接外围作用域', 所以例子的结果是 '3' 而不是 '2'.
                单纯按照代码块儿的结构来说, 在 #1 处 'b = 3' 这个约束已经不再对 'f()' 这个调用起作用, 但是从打印的结果来看显然不是这样(依然起作用).
                Python 虚拟机在执行 'f = funcO()' 的时候会执行 'def funcI():' (因为 函数 funcO return 了 funcI 函数对象),
                就在这个时候 约束'b = 3' 与函数对象 funcI 捆绑了一起, 并把捆绑后的街哦过返回, 这个捆绑起来的整体被称为 '闭包'('捆绑' 一词可以理解为 '直接外围作用域' 的绑定过程).
                闭包是 LEGB 规则中的 E -> enclosing 的首字母, 表示的是 '直接外围作用域' 这个概念.

        global 关键字,
            例子,
                c = 1
                def func1():
                    print(c)

                def func2():
                    print(c)
                    c = 3
                    print(c)

                func1()
                func2()

                Output,
                    1               # func1() 的打印
                    func2()         # func2() 的打印
                        print(c)
                            UnboundLocalError: local variable 'c' referenced before assignment

            func1 和 func2 同是对'直接外围作用域'的搜索, 为什么一个正确搜索约束 'c = 1',另一报错呢？
            先来了解一个名字的定义 - '最内嵌套作用域规则'.
                最内嵌套作用域规则：由一个赋值语句引进的名字在这个赋值语句所在的作用域里是可见（起作用）的，
                                 而且在其内部嵌套的每个作用域里也可见，除非它被嵌套于内部的，
                                 引进同样名字的另一条赋值语句所遮蔽/覆盖。

            从 exception 中得知, 变量 c 没有被定义. 上述问题就出现在'定义'的后半句，‘除非’分句 - '除非它被嵌套于内部的，
            引进同样名字的另一条赋值语句所遮蔽/覆盖。' 恰巧紧接着报错处, 通过赋值语句引进了一个同名约束('c = 3')，进而破坏了'最内嵌套作用域规则'.

            现在尝试修改这个引用错误,
                c = 1
                def func1():
                    print(c)     #1

                def func2():
                    global c     #2  在引用之前通过 global 关键字指定作用域
                    print(c)     #2
                    c = 3
                    print(c)     #3

                func1()
                func2()
                print(c)         #4

                Output,
                    1     #1
                    1     #2  python 理解了编程者的意图
                    3     #3
                    3     #4
            进一步再看一个闭包的例子，
                d = 1
                def func2():
                    d = 3
                    def func2I():
                        global d
                        print(d)          #1
                        d += 4            #2    重写直接外层作用域
                        print(d)          #2
                    return func2I

                abc = func2()
                abc()
                print(d)                  #3

                Output,
                    1        #1  global 关键字 打破 LEGB 规则, 限定引用直接外层作用于
                    5        #2  直接外层作用于被重写
                    5        #3  被重写的‘直接外作用域’(代码块儿最外层的 'd = 1' 这个约束)作用于 LEGB 规则下作用域