作用域 就是一个 Python 程序可以直接访问命名空间的正文区域。这里的直接访问意思是一个对名称的错误引用会尝试在命名空间内查找。每次执行时，至少有三个命名空间可以直接访问的作用域嵌套在一起。搜索顺序为：LEGB

命名空间 是从名称到对象的映射（例如：x=abs(-10)中，x为名称，abs(-10)为对象）。命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。命名空间主要是通过 Python 字典实现的。

不同的命名空间在不同的时刻创建，有不同的生存期。
1)、内置命名空间 —— 包含内置命名的命名空间在 Python 解释器启动时创建，会一直保留，不被删除。(B)
2)、全局命名空间 —— 模块的全局命名空间在模块定义被读入时创建，通常，模块命名空间也会一直保存到解释器退出。(G)
3)、局部命名空间 —— 当调用函数时，就会为它创建一个局部命名空间，并且在函数返回或抛出一个并没有在函数内部处理的异常时被删除。(L)

LEGB含义解释：
L-Local(function)即局部名称；函数内的名字空间
E-Enclosing function locals即函数中嵌套函数的外部；外部嵌套函数的名字空间(例如closure)
G-Global(module)即全局名称；函数定义所在模块（文件）的名字空间
B-Builtin(Python)即内置名称；Python内置模块的名字空间

LEGB就是用来规定命名空间查找顺序的规则，顺序为：local-->enclosing function locals-->global-->builtin。

局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域

Python命名空间是对变量名的分组划分,不同命名空间中的名称之间没有任何关系。命名空间是一个字典，字典内保存了变量名称与对象之间的映射关系，因此，查找变量名就是在命名空间字典中查找键-值对，想要打印出全局变量与局部变量的字典映射，我们可以使用函数globals()和locals()。

# LEGB作用域范围，不同范围作用域可以同名
v = 100      # 全局作用域G

def fun1( ):
    v = 200    # 外部嵌套函数作用域E
    print('fun1.v=', v)

    def fun2( ):
        v = 300    # 局部作用域L
        print('fun2.v=', v)
        print(max)    # max函数都没有创建，在内建函数作用域中，只读，不能改变

    fun2( )
fun1( )
print("全局变量.v=", v)
print(max)    # max变量定义在内置模块的作用域，是解释执行器提前定义好的

局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。

a = 100      # 全局变量a
def func():
    a = 250    # 给a赋值了，a就是局部变量，外部的全局变量a就不能访问了
    print(a)      # 注：如果a=250放到print(a)的后面将引发错误：局部变量“v”在赋值之前引用


#print(locals( ))     #LEGB中打印变量作用域字典

print(a)    # 打印全部变量
func( )      # 局部变量

#------------------------------------------------------------
a = 100      # 全局变量a
def func( ):
    print(a)  # 全局变量a

print(a)    # 打印全部变量
func()      # 全局变量a

#------------------------------------------------------------
a = 100      # 全局变量a
def func( ):
    a = a+1      #a+1这个a系统认为是局部变量
    print(a)   # 全局变量a
    
func( )
#UnboundLocalError: local variable 'a' referenced before assignment      

E也包含在def关键字中，L是定义在此函数内部的局部作用域，而E是定义在此函数的上一层父级函数的局部作用域。

如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数。

闭包： 即在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

def outer( ):  
    x = 1  
    def inner( ):  
        print(x)      # 外部闭包中的x,打印1  
    return inner 

foo = outer( )  
foo( )  

#------------------------------------------------------------
def outer(x):  
    def inner( ):  
        print(x) 
    return inner  

print1 = outer(1)  
print2 = outer(2)  
print1()   
print2() 

#------------------------------------------------------------
def outer( ):
    x = 1
    def inner( ):
        nonlocal x         # 指示x为闭包中的x，即外面的x
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)
    
outer()

#------------------------------------------------------------
def outer():
    x = 1
    def inner():
        #nonlocal x
        x = 2                   # x为inner函数中的局部变量，此时覆盖了闭包中的x
        print("inner:", x)
    inner()
    print("outer:", x)
    
outer()

即在模块层次中定义的变量，每一个模块都是一个全局作用域。

A = 100            # 全局变量A
def func( ):
    global  A        # 函数中的变量A都是全局变量，可以随时修改
    A = A + 200
    print(A)         # 打印300

print(A)    # 打印全局变量   100
func()      
print(A)   # 改变后的全局变量  300

系统内固定模块里定义的变量，如预定义在builtin 模块内的变量。 Python 语言内置的名称，比如函数名 abs、char 、常量True、Flase、None和异常名称 BaseException、Exception 等等。