python global和globals()函数

Love The Way You Lie 2024-04-19 15:48 107阅读 0赞

1.命名空间及作用域的基本概念

python命名空间和作用域及local,global,locals(),globals()区别 
    目录：
    
     
    1.1.模块级变量运用
     
    2.变量的作用域
    3.local,global,locals(),globals()区别
    loccals查看局部变量
    globals查看修改删除全局变量
    4.典型错误处理   
    1.1.命名空间分类：
     
    全局命名空间：记录模块变量，包括函数、类、导入模块、模块级变量和常量
    局部命名空间：函数，类，推导式名字空间叫做局部名字空间，记录参数和局部变量
    内置命名空间：任何模块均可访问它，存放着内置函数异常
    1.2.三种命名空间之间的加载与取值顺序：
     
    加载顺序：
    内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
     
    取值 ,查找变量顺序：
    局部命名空间->全局命名空间->内置命名空间
     
    局部名字空间local 本地-  特指当前函数或类方法。
    局部名字空间 Eclosing封闭-  函数体内定义函数
    全局名字空间global全局 -  特指当前模块。
    内置名字空间 built-in内置-  对每个模块都是全局的。
     
    注意：
    import module：模块自身被导，保持自已名字空间；module.function在模块的命名空间中运用
    from module import： 将module.function函数属性导入当前名字空间；可以直接使用 
    1.3.python代码运行函数机理
     
    python解释器开始执行之后，在内存中开辟一个空间，当遇到一个变量时把变量名和值
    之间对应关系记录下来。当遇到函数定义时解释器只是象征性将函数名读入内存，表示知
    道这个函数存在，至于函数内部的变量和逻辑解释器根本不关心
     
    代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间
     
    等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，
    这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。
     
    函数中变量只能在函数内部使用，随着函数执行完毕这块内存中所有内容被清空
    在函数的运行中开辟的临时的空间叫做局部命名空间
     
    内置命名空间存放python解释器提供名字input print str list tuple.等.可直接使用。

2.变量的作用域

概念：
    global变量：为全局作用域；
    nonlocal变量：为封闭作用域，系统每次执行函数时会创建新的局部命名空间
    globals()  ：以字典类型返回当前位置的全部全局变量。
    locals()  ：以字典类型返回当前位置的全部局部变量
    用途：
    用于定义，查看，修改变量
    注意：
    1）golbal用于定义全局变量
    2）nonlocal用于函数内定义局部变量
    3）globals,locals函数用名字空间来记录变量轨迹；名字空间是一个字典 {变量名：变量值}
    4）名字空间在运行时直接可以访问，可在命名空间中更改变量
    （1）局部名字空间可通过内置locals函数访问； locals是只读 不可修改；locals()返回的拷贝;修改不影响局部名字空间中变量值
    （2）全局(模块级别)名字空间可通过内置globals函数来访问；globals可以修改，返回全局名字空间；对他修改影响全局变量
     
    5）.跨模块共享全局变量
    在单个程序中跨模块共享信息的规范方式是创建一个特殊模块（通常称为config或cfg）。
    只需在应用程序的所有模块中导入配置模块;  该模块将成为全局名称。由于每个模块只有
    一个实例，因此对模块对象所做的任何更改都会反映到处。例如： 
     
    config.py：
    x = 0 # Default value of the 'x' configuration setting
    mod.py：
    import config
    config.x = 1
    main.py：
    import config
    import mod
    print(config.x)

3.实例 ：

实例1-locals()查看局部变量
    def add_tcy(a,b):
    z=a+b
    s=locals()
    locals()['z'] = -100 # 修改局部名字空间拷贝变量无影响
    return s['z'],z,s
     
    f=add_tcy(3,4) # (-100, 7, {'a': 3, 'b': 4, 'z': -100, 's': {...}})#z并未改变，改变的locals()拷贝的副本 
    实例2-globals()查看修改删除全局变量
    import os
     
    'name' in globals() #False
    globals()['name']=os.getcwd()#'C:\\python37\\Scripts'
    'name' in globals() #True
    del globals()['name']
    'name' in globals() # False 
    实例3-globals()在命名空间中修改全局变量
     
    x,y=10,20
    z=x+y
    print(z)#30
    globals()['x']=-100 # globals()修改变量x的值为-100
    z=x+y
    print(z)#80

4.实例：测试全局变量和局部变量

显示函数定义： 
    lst=[0,0]
    def view_variable(locals,globals,lst=lst):
    '''仅显示变量，去除其他显示'''
     
       def ChooseVariable(data):
         d={}
         for key,value in data.items():
             if ('__' not in key) and (not isinstance(value,dict)) and('lst' not in key):
                if 'function' in str(value):value='fun'
                d[key]=value
                lst[1]=lst[1]+1
                lst[0]=(lst[0]+1) if (lst[1]%2)==0 else lst[0]
         return d
     
         print('{}.1.locals={}'.format(lst[0],ChooseVariable(locals)))
         print('{}.2.globals={}'.format(lst[0],ChooseVariable(globals))) 
    实例1：
    g_x0=1 #全局作用域
     
    l=locals()
    g=globals()
    view_variable(l,g)
    # 1.locals={'view_variable': 'fun', 'g_x0': 1}
    # 2.globals={'view_variable': 'fun', 'g_x0': 1} 
    实例2：测试全局变量和局部变量---闭包变量测试
    g1=-1000
    def test_func():
       V0=10 #作用域为test_func函数
       l = locals()
       g = globals()
       view_variable(l, g)
     
          # 0.1.locals={'V0': 10}
          # 0.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun'}
     
       def local_func():
          V0 = 20 #作用域为本函数
          l = locals()
          g = globals()
          view_variable(l, g)
          # 1.1.locals={'V0': 20}
          # 1.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun'}
     
       def nonlocal_func():
          nonlocal V0 #作用域为test_func函数内部
          V0=15
          l = locals()
          g = globals()
          view_variable(l, g)
          # 2.1.locals={'V0': 15}
          # 2.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun'}
     
       def global_func():
          global V0 #新建global全局变量
          V0=-1
          l = locals()
          g = globals()
          view_variable(l, g)
          # 3.1.locals={}
          # 3.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun', 'V0': -1}
     
       local_func()
       print("V0=:", V0) # V0=10
       nonlocal_func()
       print("V0=:", V0) #V0=15
       global_func()
       print("V0=", V0) #同名内部优先V0=15
       l = locals()
       g = globals()
       view_variable(l, g)
       # 4.1.locals={'V0': 15, 'local_func': 'fun', 'nonlocal_func': 'fun', 'global_func': 'fun'}
       # 4.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun', 'V0': -1}
     
    测试调用
    test_func()
    print(V0) #V0=-1
    l=locals()
    g=globals()
    view_variable(l,g)
    # 5.1.locals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun', 'V0': -1}
    # 5.2.globals={'view_variable': 'fun', 'g1': -1000, 'test_func': 'fun', 'V0': -1}

5.错误处理：

实例1
    def myFunction(param1=123,param2="Python"):
       # global myVar
       for key,val in locals().items():
           print( "key==> (%s : %s)" % (key,str(val)))
       myVar = myVar + 1
     
    myVar = 27
    myFunction(12,'Tom')
    #缺省global myVar程序报错
    #输出：
    # key==> (param1 : 12)
    # key==> (param2 : Tom)
    #报错原因：局部赋值需要注意
     
    Python有如下假设，如果在函数体内的任何地方对变量赋值，则Python将名称添加到局部命名空间。
    语句myVar = myVar + 1对名称myVar进行赋值，Python假设无论在何处发生赋值，myVar都是函数myFunction局部命名空间的一部分。
    当Python尝试把1添加到myVar中时，该名称在局部命名空间中，但它没有关联值，因此报错。
        
    问题在于Python何时决定myVar出现在局部空间中，这发生在代码运行之前，即，在Python运行到函数定义之前。由于创建局部命名空间时
    （代码实际运行之前）。Python会检查代码并填充局部命名空间。在Python运行那行代码前，就发现了对myVar的赋值，并把它添加到局部
    命名空间中。当函数执行时，Python解释器认为myVar在局部命名空间中但没有值，所以会产生错误。
        
    解决办法：
    如果在函数体内，使用global语句将变量声明为全局变量，那么Python不会为该变量在命名空间中创建局部名称。 
    实例2：典型内部变量运用错误
     
    def a(x):
         print(x)
         def b():
             print(x) #报错，函数内赋值操作对外层变量屏蔽，无论赋值参数在本函数内部位置何处
             x = 20
             print(x)
         return b
     
    f=a(10)()
    print(f)
    解决办法 ： 
    
    def a(x):
         print(x)
         def b():
             nonlocal x  # python3 的 nonlocal 语句可以内部函数直接使用外部函数
             print(x) #报错，函数内赋值操作对外层变量屏蔽，无论赋值参数在本函数内部位置何处
             x = 20
             print(x)
         return b
     
    f=a(10)()
    print(f)
     
    # 10
    # 10
    # 20
    # None

这种概念性的东西不是很好理解，但是在使用中可能会因此浪费很多的时间来查找错误，平时没事多看几次吧！