python3的变量做用域规则和nonlocal关键字

也许你已经以为本身能够熟练使用python并能胜任许多开发任务，因此这篇文章是在浪费你的时间。不过别着急，咱们先从一个例子开始：

i = 0
def f():
  print(i)
  i += 1
  print(i)

f()
print(i)

猜猜看输出是什么？你会说不就是0，1，1么，真的是这样吗？

> python test.py
Traceback (most recent call last):
  File "a.py", line 7, in <module>
    f()
  File "a.py", line 3, in f
    print(i)
UnboundLocalError: local variable 'i' referenced before assignment

这是为何？若是你还不清楚产生错误的缘由，那就请继续往下阅读吧！

本文索引

• LEGB原则
• 名字隐藏和暂时性死区
• 消除暂时性死区
• 使用nonlocal声明闭包做用域变量
• 总结

LEGB原则

变量的做用域，这是一个老生常谈的问题了。

在python中做用域规则能够简单的概括为LEGB原则，也就是说，对于一个变量name，首先会从当前的做用域开始查找，若是它不在函数里那就从global开始，没找到就查找builtin做用域，若是它位于函数中，就先从local做用域查找，接着若是当前的函数是一个闭包，那么就查找外层闭包的做用域，也就是规则中的E，接着是global和builtin，若是都没找到name这个变量，则抛出NameError。

那么咱们来看一段代码：

i = 100
def f():
  print(i)

在这段代码中，print位于builtin做用域，i位于global，那么：

1. 在函数f中找不到这两个名字，因此从local向上查找，
2. 首先f不是闭包，所以跳过闭包做用域的查找，
3. 而后查找global，找到了i，但print还未找到，
4. 而后查找builtin，找到了print的builtin模块里的一个函数。

至此名字查找结束，调用找到的函数，输出结果100。

如今你可能更加疑惑了，既然查找规则按照LEGB的方向进行，那么test.py中的f不就应该找到i为global中的变量吗，为何会报错呢？

名字隐藏和暂时性死区

在揭晓答案以前，咱们先复习一下名字隐藏。

它是指一个声明在局部做用中的名字会隐藏外层做用域中的同名的对象。许多语言都遵照这一特性，python也不例外。

那么暂时性死区是什么呢？这是es6的一个概念，当你在局部做用域中定义了一个非全局的名字时，这个名字会绑定在当前做用域中，并将外部做用域的同名对象隐藏：

var i = 'hello'
function f() {
  i = 'world'
  let i
}

这段代码中函数中的i被绑定在局部做用域（也就是函数体内）中，在绑定的做用域中可见，并将外部的名字隐藏，而对一个未声明的局部变量赋值会致使错误，因此上面的代码会引起ReferenceError: i is not defined。

对于python来讲也是同样的问题，python代码在执行前首先会被编译成字节码，这就会致使某些时候实际执行的程序会和咱们看到的产生出入。不过咱们有dis模块帮忙，它能够输出python对象的字节码，下面咱们就来看下通过编译后的f：

> dis(f)

2           0 LOAD_GLOBAL              0 (print)
            2 LOAD_FAST                0 (i)
            4 CALL_FUNCTION            1
            6 POP_TOP

3           8 LOAD_CONST               1 ('a')
           10 STORE_FAST               0 (i)

4          12 LOAD_GLOBAL              0 (print)
           14 LOAD_FAST                0 (i)
           16 CALL_FUNCTION            1
           18 POP_TOP
           20 LOAD_CONST               0 (None)
           22 RETURN_VALUE

字节码的解释在这里。

其中LOAD_FAST和STORE_FAST是读取和存储local做用域的变量，咱们能够看到，i变成了局部做用域的变量！而对i的赋值早于i的定义，因此报错了。

产生这种现象的缘由也很简单，python对函数的代码是独立编译的，若是未加说明而在函数内对一个变量赋值，那么就认为你定义了一个局部变量，从而把外部的同名对象屏蔽了。这么作无可厚非，毕竟python没有独立的声明一个局部变量的语法，但结果就会形成咱们看到的相似暂时性死区的现象。因此请容许我把es6的概念套用在python身上。

消除暂时性死区

既然知道问题的症结在于python没法区分局部变量的声明和定义，那么咱们就来解决它。

对于一个能够区分声明和定义的语言来讲是没有这种烦恼的，好比c：

int i = 0;
void f(void)
{
  i++;
  printf("%d\n", i); // 1
  const char *i = "hello";
  printf("%s\n", i); // "hello"
}

python中不能这么作，可是咱们能够换一个思路，声明一个变量是全局做用域的，这样不就解决了吗？

global运算符就是为了这个目的而存在的，它声明一个变量始终是全局做用域的变量，所以只要存在global声明，那么当前做用域里的这个名字就是一个对同名全局变量的引用。改进后的函数以下：

def f():
  global i
  print(i)
  i += 1
  print(i)

如今运行程序就会是你想要的结果了：

> python test.py
0
1
1

若是你仍是不放心，那么咱们再来看看字节码：

> dis(f)

3           0 LOAD_GLOBAL              0 (print)
            2 LOAD_GLOBAL              1 (i)
            4 CALL_FUNCTION            1
            6 POP_TOP

4           8 LOAD_CONST               1 ('a')
           10 STORE_GLOBAL             1 (i)

5          12 LOAD_GLOBAL              0 (print)
           14 LOAD_GLOBAL              1 (i)
           16 CALL_FUNCTION            1
           18 POP_TOP
           20 LOAD_CONST               0 (None)
           22 RETURN_VALUE

对于i的存取已经由LOAD_GLOBAL和STORE_GLOBAL接手了，没问题。

固然global也有它的局限性：

• 一旦声明global，那么这个名字始终是global做用域的一个变量，不能够再是局部变量
• 名字必须存在于global里，由于python在运行时进行名字查找，因此你的变量在global里找不到的话对它的引用将会出错
• 接上一条，由于global限定了名字查找的范围，因此像闭包做用域的变量就找不到了

事实上须要引用非global名字的需求是极其常见的，所以为了解决global的不足，python3引入了nonlocal

使用nonlocal声明闭包做用域变量

假设咱们有一个需求，一个函数须要知道本身被调用了多少次，最简单的实现就是使用闭包：

def closure():
  count = 0
  def func():
    # other code
    count += 1
    print(f'I have be called {count} times')

  return func

仍是老问题，这样写对吗？

答案是不对，你又制造暂时性死区啦！

>>> f=closure()
>>> f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in func
UnboundLocalError: local variable 'count' referenced before assignment

这时候就要nonlocal出场了，它声明一个名字位于闭包做用域中，若是闭包做用域中未找到就报错。

因此修正后的函数以下：

def closure():
  count = 0
  def func():
    # other code
    nonlocal count
    count += 1
    print(f'I have be called {count} times')

  return func

测试一下：

>>> f=closure()
>>> f()
I have be called 1 times
>>> f()
I have be called 2 times
>>> f()
I have be called 3 times
>>> f2=closure()
>>> f2()
I have be called 1 times

如今能够正常使用和修改闭包做用域的变量了。

总结

固然，在函数里修改外部变量每每会致使潜在的缺陷，但有时这样作又是对的，因此但愿你在好好了解做用域规则的前提下合理地利用它们。

做用域规则能够总结为下：

1. 名字查找按照LEGB规则进行，若是当前代码在global中则从global做用域开始查找，不然从local开始
2. builtin做用域中是内置类型和函数，因此它们老是能被找到，前提是不要在局部做用域中对它们赋值
3. global中存放着全部定义在当前模块和导入的名字
4. local是局部做用域，存放在造成局部做用于的代码中有赋值行为的名字
5. 闭包做用域是闭包函数的外层做用域，里面能够存放一些自定义的状态
6. global声明一个名字在global做用域中
7. nonlocal声明一个名字在闭包做用域中
8. 最重要的一条，当你在能产生局部做用域的代码中对一个名字进行赋值，那么这个名字就会被认为是一个local做用域的变量从而屏蔽其余做用域中的同名对象

只要记住这些规则你就能够和因做用域引发的各类问题说再见了。并且理解了这些规则还会为你探索更深层次的python打下坚实的基础，因此请将它牢记于心。