Python中令人头疼的变量作用域问题,终于弄清楚了

时间:2022-09-11 08:08:46

我们经常听说Python函数访问局部变量、全局变量;在定义装饰器的时候,还会使用*变量。这些不同的变量是如何赋值、初始化、查找及修改的呢?各自的作用细则又是什么样的呢?本篇尝试解答这个问题。

Python中令人头疼的变量作用域问题,终于弄清楚了

Python中的变量名可以指代变量、函数、类、对象等。一般来说,每个对象都有一个变量名指向,更准确说是 绑定。

作用域的必要性

 

为啥变量要有作用域呢?

我们在Python里遇到的内置、局部、全局及*变量,就是说变量的作用域。

语言区分作用域,是为了复用变量名。引入作用域,相当于给变量划分了各自的“隔离区”,在不同”隔离区“里,查找变量变得很容易。

正是因为有了作用域,我们在函数内才可以随意使用变量名,而不担心其与全局变量、其他函数中的变量冲突——因为这两个作用域是分割的。

BASIC语言只有全局变量,你能想象吗?你在一个函数里命名的循环变量i,很可能跟全局变量冲突。写起程序来,举步维艰。且会导致很多修改、检索问题,维护很困难。

Python变量定义的时间和空间

 

Python 有哪些作用域呢?

Python是动态类型语言,变量是在定义的时候赋值的。这句话的意思我们分以下几个方面来理解:

  • a = 1 赋值时定义变量
  • from tools import cubie 导入时定义变量 cubie
  • def fun():pass 定义函数,绑定变量fun
  • def fun(name=None):pass 定义变量name为函数fun的形式变量(也是局部变量),同时定义函数,绑定便令fun
  • class Car:pass 定义类,绑定类名Car

以上,我们弄清了变量定义的时刻,下面来看变量的作用域,也就是变量的活动空间怎么规定出来的。

变量作用域取决于其 定义位置。

  • 定义在函数内部的变量、定义在函数声明中的形式参数,视为局部变量。
  • 定义在 .py 文件内的,且函数、类之外的变量,视为全局变量。
  • 定义在函数中,嵌套函数外,且被嵌套函数引用的变量,视为*变量。
  • 定义在builtin中的变量,视为内置变量。

面对如此复杂的四种变量作用域,用一个例子来说明它们的访问规则。

LEGB规则

 

四个作用域遵循LEGB规则,让我们用一个例子来说明。

  1. import builtins 
  2.  
  3. builtins.b = 'builtins' 
  4. g = 'global' 
  5.  
  6. def outer(o1,o2='o2'): 
  7.     e = 'enclose' 
  8.     def inner(i1,i2='i2'): 
  9.         print(i1,i2,o1,o2,e,g,b) 
  10.     return inner  
  11.  
  12. fun = outer('o1')  
  13. fun('i1'

其输出为 i1 i2 o1 o2 enclose global builtins

可见,在outer函数的嵌套函数inner中的输出语句 print(i1,i2,o1,o2,e,g,b) 是本程序的重点。其具体执行情况如下:

  • print i1和i2,毫无疑问的局部变量。
  • print o1和o2,本地作用域没有,向上查找到outer函数形参。形参也为局部变量,所以该变量实际定义在outer函数内,inner这个内嵌函数外,而inner内部引用了这个变量,所以视为*变量。
  • print e,本地作用域没有,类似上例,视为*变量。
  • print g,本地作用域没有,*变量作用域(闭包)没有,一直上溯到全局作用局找到。
  • print b,本地作用域没有,*变量作用域(闭包)没有,全局作用局没有,一致上溯到内置变量空间找到。

至此,LEGB规则呼之欲出:在本地空间寻找不到的变量,逐级向上级寻找。这里的LEGB分别指代Local,Enclose,Global和Builtin。

在函数中读取和赋值全局变量,在内嵌函数中读取和赋值*变量,会有一些不同的地方。

nonlocal 和 global

 

对变量名的赋值和引用,是两种不同的情况:

  • 赋值:创建一个变量或者修改。
  • 引用:检索其值。

以上两者的差别,会导致我们在函数中:

  • 赋值一个
  1. 全局变量:等于创建一个局部变量。
  2. *变量:等于创建一个局部变量。
  • 引用:正常检索其值。

我们修改上例中的inner函数为如下形式:

  1. def inner(i1,i2='i2'): 
  2.     e = 'enclose' 
  3.     g = 'inner global' 
  4.     print(i1,i2,o1,o2,e,g,b) 

在嵌套函数内,重新定义了g变量,其他语言一般理解这是重新赋值全局变量。但是我们看上条规则:在函数中,赋值一个全局变量时,等于创建一个局部变量。就是说此时的g已经是局部变量了——在程序最后的 print(g) 语句输出 global,而不是修改后的 inner global 也验证了以上规则。

完整代码如下:

  1. import builtins 
  2.  
  3. builtins.b = 'builtins' 
  4. g = 'global' 
  5.  
  6. def outer(o1,o2='o2'): 
  7.     e = 'enclose' 
  8.     g = 'inner global' 
  9.     def inner(i1,i2='i2'): 
  10.         print(i1,i2,o1,o2,e,g,b) 
  11.     return inner  
  12.  
  13. fun = outer('o1')  
  14. fun('i1'
  15.  
  16. print(g) 

输出结果如下:

  1. i1 i2 o1 o2 enclose inner global builtins 
  2. global 

不重新赋值,只是使用全局变量和*变量,则没有问题。

*变量也是类似的情况。

为了解决局部作用域中赋值全局变量和*变量导致的变成局部变量问题,Python引入关键字 global 和 nonlocal 。

  1. def inner(i1,i2='i2'): 
  2.     global g 
  3.     nonlocal e 
  4.     g = 'inner global' 
  5.     e = 'inner enclose' 

此时的赋值,则分别是对全局变量和*变量的操作,而非新建局部变量。

完整代码如下:

  1. import builtins 
  2.  
  3. builtins.b = 'builtins' 
  4. g = 'global' 
  5.  
  6. def outer(o1,o2='o2'): 
  7.     e = 'enclose' 
  8.     def inner(i1,i2='i2'): 
  9.         global g 
  10.         nonlocal e 
  11.         g = 'inner global' 
  12.         e = 'inner enclose' 
  13.         print(i1,i2,o1,o2,e,g,b) 
  14.     return inner  
  15.  
  16. fun = outer('o1')  
  17. fun('i1'
  18.  
  19. print(g) 

输出结果如下:

  1. i1 i2 o1 o2 inner enclose inner global builtins 
  2. inner global 

总结

 

  • Python的作用域分为四种,分别是局部、全局、*和内置;
  • 定义变量的位置决定了变量的作用域;
  • 作用域的查找遵守LEGB规则;
  • 为了在局部作用域中修改全局变量和*变量,引入了 global 关键字和 nonlocal 关键字。

原文链接:https://mp.weixin.qq.com/s?__biz=MzI2NjY5NzI0NA==&mid=2247499418&idx=2&sn=9bd72d019bcc4ce19bc9fabb5229b608&chksm=ea8891e9ddff18ff089244dcaa3fae27857fe743b835ef04adf5492eb3ac9ca867c043051fae&mpshare=1&