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()                         #

                 Output,
                         3                   #1

                 例子的输出结果是 '' 而不是代码块儿最外层所定义的 'b = 2'.
                 f() 实际调用的内嵌在 funcO 中的 funcI 函数. funcI 位于 funcO 之内, 所以函数 funcI 的作用域内嵌于函数 funcO 的作用域内.
                 即, 函数 funcO 的作用域是内嵌函数 funcI 的'直接外围作用域', 所以例子的结果是 '' 而不是 ''.
                 单纯按照代码块儿的结构来说, 在 #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)     #

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

                 func1()
                 func2()
                 print(c)         #

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

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

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