Python 学习之作用域

Dear 丶 2022-03-12 12:25 212阅读 0赞

# Python 学习之作用域 #

### 文章目录 ###

*  Python 学习之作用域
 *   *  问题的引出
     *  代码块
     *  名称的绑定
     *  三种变量
     *  作用域
     *  名称解析
     *  LEGB 作用域查找规则
     *  global 和 nonlocal
     *   *  global
         *  nonlocal
     *  注意
     *  参考资料

## 问题的引出 ##

请看这样一段代码：

**例1**

# test01.py
    n = 5
    
    def test():
        n += 1
        print(n)
    
    test()

猜猜运行结果是什么？

咱们运行一下：

$ python3 test01.py
    Traceback (most recent call last):
      File "test01.py", line 8, in <module>
        test()
      File "test01.py", line 5, in test
        n += 1
    UnboundLocalError: local variable 'n' referenced before assignment

居然出错了，难道不应该是输出6吗？其实，要想弄清楚这个问题，就要系统地学习一些概念。

## 代码块 ##

Python 程序是由代码块构成的。代码块是被作为一个单元来执行的一段 Python 程序文本。以下几个都是代码块：**模块、函数体和类定义**。

## 名称的绑定 ##

名称用于指代对象（你可以理解为名称是一个指向对象的指针）。名称是通过名称绑定操作来引入的。以下构造会绑定名称：传给函数的正式形参，`import` 语句，类定义，函数定义，以标识符为目标的赋值，`for`循环的开头等等等等。

总之，就本文讨论的问题，我们只要记住 **以标识符为目标的赋值会绑定名称** 就可以了。

## 三种变量 ##

如果名称绑定在一个代码块中，则为该代码块的局部变量（通俗地说该代码块内定义了一个局部变量），除非声明为 `nonlocal` 或 `global`。如果名称绑定在模块层级，则为全局变量。(模块代码块的变量既为局部变量又为全局变量。) 如果变量在一个代码块中被使用但不是在其中定义，则为自由变量。

读到这里，你可以先简单理解为def之外定义的变量就是全局变量，def之内定义的变量就是局部变量，只读不修改的变量就是自由变量。

再回头看看例1的代码，我新增加了第2行和第5行的注释。

# test01.py
    n = 5   # 名称绑定在模块层级，n为全局变量
    
    def test():
        n += 1 # 因为有赋值操作，所以是名称绑定。 名称绑定在函数内，n为局部变量，这个n不是第2行的那个n
        print(n)
    
    test()

## 作用域 ##

作用域定义了一个名称在代码块内的可见性。

如果代码块中定义了一个局部变量，则其作用域包含该代码块，也就是说这个名称在该代码块内是可见的。如果定义（名称绑定）发生于函数代码块中，则其作用域会扩展到该函数所包含的任何代码块，除非有某个被包含代码块引入了对该名称的不同绑定。

名称绑定的位置决定了这个名称的作用域。也就是说，一个变量的作用域总是由它在代码中被赋值的地方所决定。

一般来说，变量可以在3个不同的地方赋值，分别对应3种不同的作用域：

1.  如果一个变量在def内赋值，则它被定位在这个函数之内；
2.  如果一个变量在一个嵌套的def中赋值，对于外层的def来说，它是非本地的（即它不属于外层函数）；
3.  如果一个变量在def之外赋值，它就是全局的。

注意：**一个函数内部的任何类型的赋值都会把一个名称划定为本地的**。这包括`=`语句，`import`中的模块名称，`def`中的函数名称，函数参数名称等。

## 名称解析 ##

所谓名称解析，我的理解就是确定一个名称到底指代哪个对象。举个例子，全国有成千上万个叫“王东”的，我说王东欠我80万，你知道我说的是哪个王东吗？

当一个名称在代码块中被使用时，会由包含它的最近（这里的近是指地理位置近）作用域来解析。在最近作用域中，这个名称被绑定到了哪个对象，它就指代那个对象。如果完全找不到这个名称，将会引发`NameError`异常。

**例2**：

# test02.py
    n = 5    # 名称绑定在模块层级，n为全局变量
    
    def test():
        n = 6  # 名称绑定在函数内，n为局部变量，这个n不是第2行的那个n
        print(n) # 包含n的最近作用域是函数作用域，所以这个n就是第5行的n
    
    test()

这个例子的结果是输出6。

如果一个代码块内的任何位置发生名称绑定操作，则代码块内所有对该名称的使用都会被认为是对当前代码块的引用。当一个名称在其被绑定前就在代码块内被使用时则会导致错误。这是一个很微妙的规则。Python 缺少声明语法，并允许名称绑定操作发生于代码块内的任何位置。一个代码块的局部变量可通过在整个代码块文本中扫描名称绑定操作来确定。

一个典型的例子是：如果名称绑定发生于函数代码块中，但是该名称被使用的时候尚未绑定到特定值，那么将会引发`UnboundLocalError`异常。`UnboundLocalError` 为 `NameError` 的一个子类。

讲到这里，你应该明白例1为什么会报错了吧。

请注意第5行的注释。

# test01.py
    n = 5
    
    def test():
        n += 1  # 这句确实是名称绑定，但是先要读出n的值，这时候n尚未绑定到特定值。
        print(n)
    
    test()

咱们再看一个例子。  
**例3**

# test03.py
    n = 5
    
    def test():
        print(n)
        n = 7
    
    test()

请思考一下，结果会是什么。

结果是：

$ python3 test03.py 
    Traceback (most recent call last):
      File "test03.py", line 8, in <module>
        test()
      File "test03.py", line 5, in test
        print(n)
    UnboundLocalError: local variable 'n' referenced before assignment

同例1一样，发生了 `UnboundLocalError`

我们分析一下，请看注释：

# test03.py
    n = 5      # 名称绑定在模块层级，n为全局变量
    
    def test():
        print(n)
        # 如果一个代码块内的任何位置发生名称绑定操作，
        # 则代码块内所有对该名称的使用都会被认为是对当前代码块的引用，
        # 所以这里的n就是第10行的n，n的使用在第10行的绑定之前，所以会导致错误
        
        n = 7   # 发生了名称绑定，代码块内所有对该名称的使用都会被认为是这个n
    
    test()

## LEGB 作用域查找规则 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM0OTA4OTY_size_16_color_FFFFFF_t_70]

前文已经说过：当一个名称在代码块中被使用时，会由包含它的最近作用域来解析。具体来说，当引用一个变量时，Python 按照以下顺序查找：

1.  本地变量（in the **local** scope）
2.  任意上层函数的作用域（in any **enclosing** functions’ local scopes）
3.  全局作用域（in the **global** scope）
4.  内置作用域（in the **built-in** scope）

Python 会在第一处能找到这个变量名的地方停下来。

## global 和 nonlocal ##

global 语句用来表明特定变量生存于全局作用域并且应当在其中被重新绑定；nonlocal 语句表明特定变量生存于外层作用域并且应当在其中被重新绑定。

也许你不理解这句话，没有关系，下文会举例说明。

### global ###

如果需要给一个在函数内部却属于模块顶层的变量名赋值，需要在函数内部用 global 语句声明。

**例4**

# test04.py
    n = 5
    
    def test():
        global n  # 声明函数内的n是第2行的全局变量n
        n += 1    # 全局变量n加1
        print(n)  # 打印全局变量
        
    test()  # 输出 6
    print(n) # 输出 6，说明全局变量确实被修改了

**例5**

# test05.py
    n = 5  # 名称绑定在模块层级，n为全局变量
    
    def test():
        print(n)  # 引用第2行的全局变量，可以不声明
        
    test() # 输出5

**要点**

全局变量如果在函数内被赋值的话，必须经过声明。

全局变量如果是在函数内被引用（只是读），可以不声明。

### nonlocal ###

如果需要给一个在嵌套的def中却属于外层函数的变量名赋值，需要在嵌套的def中用 nonlocal 声明（从Python 3.0 开始）。

如果没有声明，这些变量将是只读的（尝试写入这样的变量只会在最内层作用域中创建一个新的局部变量，而同名的外部变量保持不变）。

**例6**

# test06.py
    x = 99  # 名称绑定在模块层级，x为全局变量
    
    def f1():
        x = 88   # 名称绑定在函数f1内，x为函数f1的局部变量
        def f2():
            print(x) # 根据LEGB规则，引用第5行的x
        f2()
    
    f1() # 输出88

**例7**

# test07.py
    def func():
        x = 66  # 名称绑定在函数func内，x为函数func的局部变量
        def nested():
            nonlocal x  # 声明x是外层函数中的x，即第3行定义的x
            x = 88      # 修改第3行的x，而不是重新定义一个x
        nested()
        print(x)
    
    func()  # 输出88

如果去掉第5行：

**例8**

# test08.py
    def func():
        x = 66     # 名称绑定在函数func内，x为函数func的局部变量
        def nested():
            x = 88      # 重新定义一个x，不同于第3行的x
        nested()
        print(x)       # 引用第3行的x
    
    func()  # 输出66

## 注意 ##

1.  自由变量的名称解析发生于运行时，而不是编译时。
2.  原处改变对象并不会把变量划分为本地变量，实际上只有对变量名赋值才可以。

**例9**

i = 10
    def f():
        print(i)  # i是自由变量，在运行时解析。虽然它就是指第1行的i，但是在运行时，i的值是42
    i = 42
    f()  # 打印42

**例10**

# test10.py
    lst = [1,2,3]
    
    def test():
        print(lst)    # 引用第2行的lst
        lst[0] += 10  # 原处改变对象，而不是对变量名lst赋值，此处的lst是引用第2行的lst
        print(lst)
    
    test()
    print(lst)

运行结果是：

$ python3 test10.py 
    [1, 2, 3]
    [11, 2, 3]
    [11, 2, 3]

【End】

## 参考资料 ##

《Learning Python，5th Edition》

《Python Tutorial，Release 3.7.2》

《The Python Language Reference, Release 3.7.2》

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM0OTA4OTY_size_16_color_FFFFFF_t_70]: /images/20220312/471fe711026e495fa188dfed98a05607.png