Python 全局变量与局部变量作用域问题深度解析

作者：新兰2026.11.07 01:13浏览量：0

简介：本文以函数作用域为切入点，系统讲解 Python 中全局变量与局部变量的区别、常见报错分析方法和变量查找规则。读者将理解为什么在一个函数中直接访问另一个函数内的变量会报错，并掌握按“从最后一行往上看”的方式快速定位代码错误。

一、从一个常见报错说起

在 Python 编程中，很多初学者都会遇到类似下面这样的代码：

  1. def f1():
  2.     a = 520
  4. def f2():
  5.     b = 1314
  6.     print(a, b)
  8. f2()

这段代码看起来并不复杂：定义了两个函数，一个叫 f1，另一个叫 f2；在 f1 中给变量 a 赋值为 520，在 f2 中给变量 b 赋值为 1314，然后尝试打印 a 和 b；最后调用 f2()。

但如果将这段代码保存为 .py 文件并运行，程序并不会顺利输出 520 1314，而是会抛出异常。报错的核心信息通常是：

  1. NameError: name 'a' is not defined

也就是说，Python 解释器认为变量 a 没有定义。

很多初学者在这里会困惑：明明已经在 f1 中定义了 a，为什么在 f2 中不能用？

要回答这个问题，需要从函数作用域和变量的可见范围说起。

二、函数作用域决定了变量在哪里有效

2.1 作用域的基本含义

简单来说，作用域就是一个变量在代码中能够被访问到的区域。Python 中的变量并不是在定义之后就可以在文件的任意位置随意使用的，而是受到代码结构，尤其是函数边界的限制。

在一个函数内部定义的变量，默认属于这个函数的局部命名空间。它的有效范围从定义开始，到函数体结束为止。一旦超出这个范围，这个变量对于外部代码来说就仿佛不存在。

例如：

  1. def f1():
  2.     a = 520

变量 a 是在 f1 的函数体内赋值的，因此它属于 f1 的局部变量。当 f1 执行结束后，变量 a 的声明周期也随之结束。其他函数无法直接访问它。

2.2 两个函数之间的变量隔离

回到最开始的代码：

  1. def f1():
  2.     a = 520
  4. def f2():
  5.     b = 1314
  6.     print(a, b)

函数 f1 的作用域范围是从函数声明开始，到函数体内的最后一条语句结束。函数 f2 的作用域范围也是自身的函数体。

因此，a 只存在于 f1 的作用域中，b 只存在于 f2 的作用域中。f2 中的 print(a, b) 尝试访问 a，但 f2 内部并没有定义过 a，所以 Python 解释器会沿着变量查找规则寻找 a。如果最终找不到，就会抛出 NameError。

这里需要特别注意的是，即使 f1 在 f2 之前定义，也并不意味着 a 对 f2 可见。因为变量是否可见并不取决于函数定义的先后顺序，而是取决于作用域规则。

三、全局变量和局部变量的核心区别

在 Python 中，当我们讨论“全局变量变为局部变量”这一类问题时，本质上是在讨论变量赋值位置对变量作用域的影响。

3.1 在模块顶层定义的变量属于全局变量

如果一个变量是在函数外部、文件的最外层定义的，那么它就是一个全局变量。全局变量对整个模块中的函数通常是可见的。

例如：

  1. x = 100
  3. def show():
  4.     print(x)
  6. show()

运行结果是：

  1. 100

这里 x 定义在模块顶层，因此它是全局变量。在 show 函数内部没有重新给 x 赋值，因此访问 x 时会找到模块级别的全局变量。

3.2 在函数内部赋值会创建局部变量

再看另一个例子：

  1. x = 100
  3. def change():
  4.     x = 200
  5.     print(x)
  7. change()
  8. print(x)

运行结果是：

  1. 200
  2. 100

在 change 函数内部执行了 x = 200，这会在 change 的局部作用域中创建一个新的局部变量 x，而不会修改外部的全局变量 x。

这也是很多开发者容易混淆的一点：只要在函数内部对变量进行了赋值，Python 就会把这个变量视为该函数的局部变量，而不是去修改全局变量。

3.3 全局变量与局部变量同名时，局部优先

当全局变量和局部变量重名时，在函数内部访问变量，局部变量会优先被使用。

例如：

  1. value = 10
  3. def test():
  4.     value = 20
  5.     print(value)
  7. test()

输出结果是：

  1. 20

因为在 test 内部，value 是一个局部变量，函数内部访问时会优先使用局部变量。

四、如何理解“全局变量变为局部变量”

很多开发者在讨论“全局变量变为局部变量”时，往往是因为代码中出现了下面这类情况：

  1. count = 0
  3. def update():
  4.     print(count)
  5.     count = count + 1
  7. update()

从直觉上看，print(count) 似乎应该先打印全局变量 count 的值 0，然后再执行 count = count + 1。但实际上，这段代码会报错：

  1. UnboundLocalError: local variable 'count' referenced before assignment

原因在于 Python 的变量名解析规则。当 Python 解释器看到一个函数内部存在对某个变量的赋值语句时，它会把这个变量当作局部变量来处理。也就是说，整个函数体内，这个变量都被视为局部变量，而不会去查找全局变量。

因此，print(count) 在函数内访问的是一个尚未赋值的局部变量 count，于是就会抛出 UnboundLocalError。

这也就是很多人所说的“全局变量变为局部变量”：在函数内部一旦出现了赋值操作，这个变量在整个函数作用域内都会被当作局部变量来处理。

五、变量查找顺序与作用域层级

Python 中的变量查找遵循 LEGB 规则，即按照以下顺序查找：

  1. Local：局部作用域，也就是当前函数内部；
  2. Enclosing：嵌套函数的外层函数作用域；
  3. Global：全局作用域，也就是模块级别；
  4. Built-in：内置作用域，比如 len、print 等内置名称。

以刚才的代码为例：

  1. a = 10
  3. def outer():
  4.     a = 20
  6.     def inner():
  7.         print(a)
  9.     inner()
  11. outer()

运行结果为：

  1. 20

查找顺序是：先在 inner 的局部作用域中查找 a，没有找到；再到外层函数 outer 的作用域中查找 a，找到了 20；于是直接使用 20，不会再继续查找全局作用域中的 10。

这也能解释为什么作用域层级会直接影响变量的访问结果。

六、如何正确理解 Python 的报错信息

对于 Python 初学者来说，学会阅读报错信息是一项非常实用的技能。很多人在看到一大段报错时会从上往下逐行阅读，其实更高效的方法往往是从下往上看。

6.1 最近一次调用在最下面

Python 的异常信息通常以类似下面的形式输出：

  1. Traceback (most recent call last):
  2.   File "example.py", line 8, in <module>
  3.     f2()
  4.   File "example.py", line 6, in f2
  5.     print(a, b)
  6. NameError: name 'a' is not defined

这里最关键的一行是最后一行：

  1. NameError: name 'a' is not defined

它直接说明了错误类型和原因：变量 a 未定义。

倒数第二行与倒数第三行则帮助开发者定位错误发生的位置：

  1. File "example.py", line 6, in f2
  2.     print(a, b)

它表示真正出错的代码是文件 example.py 第 6 行，位于函数 f2 内部。

6.2 报错中会展示调用链

在异常信息中，可能同时出现多个文件和多行内容。这种现象通常是因为代码之间存在调用关系。

例如，最开始的例子中：

  • 第 8 行 f2() 是触发错误的入口；
  • 第 6 行 print(a, b) 是真正出错的代码。

Python 解释器为了帮助开发者理解执行路径，会把调用链也打印出来。调用链的信息通常从上往下表示调用顺序，而真正需要注意的错误原因则在最后一行。

因此，遇到复杂报错时，建议先看最后一行错误类型，再倒着向上查看具体出错的代码位置和调用关系。

七、实用建议与常见错误规避

7.1 避免在不同函数之间直接共享局部变量

不同函数之间的局部变量是相互隔离的。如果一个函数需要使用另一个函数中产生的数据，可以通过参数传递或者返回值的方式进行。

例如，将前面的错误示例改写为：

  1. def f1():
  2.     a = 520
  3.     return a
  5. def f2():
  6.     b = 1314
  7.     a = f1()
  8.     print(a, b)
  10. f2()

这样，f1 通过 return 返回变量 a，f2 通过调用 f1() 获取这个值，再参与后续计算或输出。

7.2 确需在函数内部修改全局变量时，应显式声明

如果确实需要在函数内部修改某个全局变量，可以使用 global 关键字显式声明。例如：

  1. count = 0
  3. def update():
  4.     global count
  5.     count = count + 1
  7. update()
  8. print(count)

这样，在 update 函数中，count 就会被视为全局变量，修改操作会直接作用于模块级别的 count。

不过，过多使用 global 通常会让代码的可维护性下降。更好的做法是通过参数传递和返回值来管理状态变化。

7.3 注意函数内赋值语句对作用域的影响

在函数中即使只是对变量重新赋值，也会让 Python 把这个变量视为局部变量。如果想在函数内部读取全局变量而不修改它，直接访问即可；但如果后续需要修改变量，就要注意是否触发 UnboundLocalError。

例如，下面写法就是错误的：

  1. total = 0
  3. def add(n):
  4.     total = total + n
  5.     return total
  7. print(add(5))

正确做法是使用 global：

  1. total = 0
  3. def add(n):
  4.     global total
  5.     total = total + n
  6.     return total
  8. print(add(5))

或者改为通过参数传递：

  1. def add(current, n):
  2.     return current + n
  4. total = 0
  5. total = add(total, 5)
  6. print(total)

八、小结

Python 中全局变量与局部变量的关系，并不是变量名称是否相同那么简单，而是由作用域规则决定的。函数内部的赋值语句会创建局部变量；不同函数之间的局部变量相互隔离；模块顶层定义的变量属于全局变量，可以在函数中被读取，但如果要在函数内部修改全局变量，则需要显式使用 global 声明。

当程序抛出 NameError 或 UnboundLocalError 时，可以结合异常信息从最后一行开始分析。最后一行通常直接说明错误类型和原因，再结合上方调用链定位具体代码位置，往往能够快速找到问题所在。

理解作用域和变量查找规则，不仅有助于排查错误，也能帮助开发者在编写函数时更清晰地设计数据传递方式，减少全局变量的滥用，写出结构更清晰、可维护性更高的代码。

最热文章