变量作用域是Python编程中非常重要的基础概念，理解它可以帮助你避免很多常见的错误。本文将用简单易懂的方式，带你全面掌握Python变量作用域的所有细节。

一、什么是变量作用域？

变量作用域（Scope）指的是变量在程序中的可见范围，也就是在程序的哪些地方可以访问这个变量。Python中有4种作用域，按照从内向外的顺序分别是：

1. 局部作用域（Local） - 在函数内部定义的变量

2. 嵌套作用域（Enclosing） - 在嵌套函数的外层函数中定义的变量

3. 全局作用域（Global） - 在模块（文件）顶层定义的变量

4. 内置作用域（Built-in） - Python内置的变量（如print、int等）

二、局部作用域（Local Scope）

在函数内部定义的变量属于局部作用域，只能在函数内部访问。

def my_function():local_var = "我是局部变量"print(local_var)  # 可以访问my_function()
print(local_var)  # 报错：NameError: name 'local_var' is not defined

特点：

• 函数调用时创建，函数结束时销毁

• 不同函数中可以定义同名局部变量，互不影响

三、全局作用域（Global Scope）

在函数外部定义的变量属于全局作用域，可以在整个模块中访问。

global_var = "我是全局变量"def func1():print(global_var)  # 可以访问def func2():print(global_var)  # 可以访问func1()
func2()
print(global_var)  # 可以访问

四、global关键字

如果要在函数内部修改全局变量，需要使用global关键字声明。

count = 0def increment():global count  # 声明使用全局变量count += 1increment()
print(count)  # 输出: 1

如果不使用global： 

count = 0def increment():count = 1  # 这实际上是创建了一个新的局部变量print("函数内:", count)increment()  # 输出: 函数内: 1
print("函数外:", count)  # 输出: 函数外: 0

五、嵌套作用域（Enclosing Scope）

在嵌套函数中，外层函数的变量对内层函数可见。

def outer():outer_var = "外层变量"def inner():print(outer_var)  # 可以访问外层变量inner()outer()

nonlocal关键字

如果要修改嵌套作用域中的变量，需要使用nonlocal关键字。

def outer():x = 1def inner():nonlocal x  # 声明使用外层变量x = 2print("inner:", x)inner()print("outer:", x)outer()
"""
输出:
inner: 2
outer: 2
"""

六、作用域查找规则：LEGB

Python查找变量时按照LEGB规则依次查找：

1. Local - 局部作用域

2. Enclosing - 嵌套作用域

3. Global - 全局作用域

4. Built-in - 内置作用域

如果都找不到，就会抛出NameError异常。

x = "global"def outer():x = "enclosing"def inner():x = "local"print(x)  # 输出: localinner()outer()

 变量查找链（LEGB）:
inner()调用时print(x)的查找过程:
1. 先在inner的局部作用域找 → 找到"local"（停止查找）
   ↑
2. 如果没找到，会去outer的作用域找 → "enclosing"
   ↑
3. 如果还没找到，会去全局作用域找 → "global"
   ↑
4. 最后会去内置作用域找

如果删除inner中的x赋值

修改代码：

x = "global"def outer():x = "enclosing"def inner():# 删除了x = "local"print(x)  # 现在会输出什么？inner()outer()

执行过程：

1. inner()中print(x)查找x：

   • Local：未找到
     → 向上查找Enclosing作用域（outer的局部作用域）

2. 找到outer中的x = "enclosing"

   • 输出: enclosing

七、常见作用域陷阱

1. 在循环/条件语句中没有独立作用域

Python中只有函数、类和模块会创建新的作用域，循环和条件语句不会。

if True:var_in_if = "if中的变量"print(var_in_if)  # 可以访问，输出: if中的变量for i in range(1):var_in_for = "for中的变量"print(var_in_for)  # 可以访问，输出: for中的变量

2. 列表推导式中的变量泄露

Python 3.x中列表推导式有自己独立的作用域，但Python 2.x中会泄露到外部作用域。

# Python 3.x
x = "hello"
[print(x) for x in range(3)]
print(x)  # 输出: hello（x没有被修改）# Python 2.x中x会被修改为2

3. 默认参数的作用域

默认参数在函数定义时求值，而不是在调用时。

def func(a, lst=[]):  # 默认列表在函数定义时创建lst.append(a)return lstprint(func(1))  # [1]
print(func(2))  # [1, 2] 使用的是同一个列表

具体过程：

1. 当Python解释器读取到函数定义时，它会创建一个空列表对象作为默认参数

2. 这个列表对象会被绑定到函数的__defaults__属性中

3. 每次调用函数时，如果没有提供lst参数，就会使用这个同一个列表对象

实际执行过程

print(func(1))  # 第一次调用
"""
1. 没有提供lst参数，使用默认列表（假设内存地址为0x1000）
2. 向这个列表添加1 → [1]
3. 返回这个列表
输出: [1]
"""print(func(2))  # 第二次调用
"""
1. 仍然没有提供lst参数，使用同一个默认列表（还是0x1000）
2. 这个列表已经是[1]了，现在添加2 → [1, 2]
3. 返回这个列表
输出: [1, 2]
"""

为什么这是个问题？

1. 不符合直觉：大多数人期望每次调用都使用一个新的空列表

2. 隐藏的共享状态：函数调用之间意外共享了数据

3. 难以调试：这种行为不明显，可能导致难以发现的bug

正确的做法

使用None作为默认值，然后在函数内部创建新列表：

def func(a, lst=None):if lst is None:lst = []lst.append(a)return lst

 现在每次调用都会得到预期行为：

print(func(1))  # [1]
print(func(2))  # [2] 这次是全新的列表

八、闭包和作用域

闭包（Closure）是函数记住并访问其词法作用域的能力，即使函数在其原始作用域之外执行。

def outer_func(x):def inner_func(y):return x + y  # inner_func记住了x的值return inner_funcclosure = outer_func(10)
print(closure(5))  # 输出: 15

九、实际应用建议

1. 避免过多使用全局变量：会使代码难以维护和调试

2. 合理使用函数封装：将相关代码和变量组织在函数中

3. 注意变量命名：避免内外作用域同名变量引起混淆

4. 使用nonlocal替代全局变量：当需要在嵌套函数中修改外层变量时

十、作用域相关面试题

1. 下面代码的输出是什么？

x = 5def func():print(x)x = 10func()

答案：会报错，因为在函数中给x赋值，Python会认为x是局部变量，但在print时x还未定义

1. 如何修改下面的代码使其正常工作？

total = 0def add_numbers(numbers):for num in numbers:total += numreturn totalprint(add_numbers([1, 2, 3]))

答案：需要在函数内使用global total声明

总结

理解Python变量作用域是写出高质量代码的基础。记住以下几点：

1. 牢记LEGB查找顺序

2. 修改作用域变量需要使用global或nonlocal

3. 只有函数、类和模块会创建新作用域

4. 避免滥用全局变量

5. 合理使用闭包特性

希望这篇文章能帮助你彻底掌握Python变量作用域！如果有任何问题，欢迎在评论区留言讨论。