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&

标签：

相关文章