Python变量作用域LEGB和变量名的查找规则

系统 1483 0

作用域LEGB

作用域:变量起作用的范围。
LEGB含义解释:
L — Local(function)局部作用域;函数内的命名空间 ,可以通过locals() 查看。
E —Enclosing function locals外部嵌套作用域;外部嵌套函数的命名空间(例如closure闭包函数)
G —Global(module)全局作用域;函数定义所在模块(.py文件)内的命名空间,可以通过globals() 查看。
B —Builtin(Python)内置模块作用域;Python内置模块的命名空间(builtins.py文件) ,可以通过 dir( builtins ) 查看。

注意:for,while循环并不会产生一个新的命名空间。

变量名的查找规则

由内到外:L -> E -> G -> B
在访问变量时,先查找本地变量,然后是包裹此函数外部的函数内部的变量,之后是全局变量,最后是内置变量。

局部变量
定义在函数内部的变量(形参也是局部变量)
只能在函数内部使用
调用函数时才被创建,函数结束后自动销毁

全局变量
定义在函数外部,模块内部的变量。
在整个模块(py文件)范围内访问(但函数内直接能读不能将其直接赋值,需要关键字global先声明可以)。

global的使用

global 语句
作用:
– 在函数内部修改全局变量。
– 在函数内部定义全局变量(全局声明)。
语法
global 变量1, 变量2, …
说明
– 在函数内直接为全局变量赋值,视为创建新的局部变量。
– 不能先声明局部的变量,再用global声明为全局变量。

案例分析:
1, 在函数内部可以直接引用外部变量(仅读):

            
              a 
              
                =
              
              
                100
              
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              a
              
                )
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                # 100
              
            
          

2,在函数内试图直接对一个全局变量赋值(直接写),仅视为创建新的局部变量:

            
              a 
              
                =
              
              
                100
              
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
    a 
              
                =
              
              
                200
              
              
                print
              
              
                (
              
              a
              
                )
              
              
                # 200
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              a
              
                )
              
              
                # 100
              
            
          

3,如果想要在函数内部引用全局变量,可以使用global关键字

            
              a 
              
                =
              
              
                100
              
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
                global
              
               a
    a 
              
                =
              
              
                200
              
              
                print
              
              
                (
              
              a
              
                )
              
              
                # 200
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              a
              
                )
              
              
                # 200
              
            
          

4,在函数内部是可以用global定义新的全局变量的:

            
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
                global
              
               c
    c 
              
                =
              
              
                200
              
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200 
              
            
          

5, 不能 先声明局部的变量,后再用global声明其为全局变量

            
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
    c 
              
                =
              
              
                100
              
              
                #不能在定义一个局部变量之后,后用global声明它是全局变量
              
              
                global
              
               c
    c 
              
                =
              
              
                200
              
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200
              
              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200
              
            
          

将会报错:

            
              
                global
              
               c
    
              
                ^
              
              
SyntaxError
              
                :
              
               name 
              
                'c'
              
              
                is
              
               assigned to before 
              
                global
              
               declaration

            
          

nonlocal

作用:
在内层函数引用修改外层嵌套函数内的变量。(函数是可以嵌套的,如闭包)
语法
nonlocal 变量名1,变量名2, …
说明
在被嵌套的内函数中进行使用
不能先声明局部的变量,后再用nonlocal 声明其为外部嵌套变量
案例:
在函数内部

            
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
    c 
              
                =
              
              
                200
              
              
                def
              
              
                inner
              
              
                (
              
              
                )
              
              
                :
              
              
                nonlocal
              
               c
        
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200
              
              
                return
              
               inner



              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                (
              
              
                )
              
            
          

不能 先声明局部的变量,后再用nonlocal 声明其为外部嵌套变量

            
              
                def
              
              
                outer
              
              
                (
              
              
                )
              
              
                :
              
              
    c 
              
                =
              
              
                200
              
              
                def
              
              
                inner
              
              
                (
              
              
                )
              
              
                :
              
              
        c 
              
                =
              
              
                100
              
              
                #不能先声明局部的变量,后再用nonlocal 声明其为外部嵌套变量
              
              
                nonlocal
              
               c
        
              
                print
              
              
                (
              
              c
              
                )
              
              
                # 200
              
              
                return
              
               inner


              
                if
              
               __name__ 
              
                ==
              
              
                "__main__"
              
              
                :
              
              
    outer
              
                (
              
              
                )
              
              
                (
              
              
                )
              
            
          

将会报错:

            
              
                nonlocal
              
               c
    
              
                ^
              
              
SyntaxError
              
                :
              
               name 
              
                'c'
              
              
                is
              
               assigned to before 
              
                nonlocal
              
               declaration

            
          

更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧,狠狠点击下面给点支持吧,站长非常感激您!手机微信长按不能支付解决办法:请将微信支付二维码保存到相册,切换到微信,然后点击微信右上角扫一扫功能,选择支付二维码完成支付。

【本文对您有帮助就好】

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧,站长会非常 感谢您的哦!!!

发表我的评论
最新评论 总共0条评论