在Python中,变量不是存储值的“容器”,而是指向对象的“标签”或“引用”。当执行 name = "Python" 时,实际发生的是:创建一个字符串对象 "Python",然后让变量 name 指向它。变量本身没有类型,类型属于对象本身。
所谓“调用变量”,实质是通过变量名访问其引用的对象内容。但这一过程受**作用域(Scope)**与**命名空间(Namespace)**严格约束,理解它们是掌握Python变量调用的关键前提。
在Python中,变量名解析遵循LEGB规则——Local(局部)、Enclosing(嵌套)、Global(全局)、Built-in(内置),这是所有变量查找的底层逻辑。若违反作用域规则,将直接抛出 NameError 或 UnboundLocalError。
作用域定义了变量在代码中的可见范围。Python采用**词法作用域**(静态作用域),即变量查找路径在函数定义时即已确定,而非在调用时动态决定。
四类作用域层级关系如下:
len、print、Exception示例:作用域层级演示
pi = 3.14159 # Global scope
def outer():
radius = 5 # Enclosing scope
def inner():
diameter = 2 * radius # Local scope
return diameter
return inner()
print(outer()) # 输出 10
当 inner() 执行时,变量 radius 在 Local 中未找到,按 LEGB 顺序向上查找,在 Enclosing 层找到;若未找到则继续向上至 Global,最后 Built-in。
LEGB 是 Python 解释器解析变量名的顺序:Local → Enclosing → Global → Built-in。该机制保证变量查找的一致性与可预测性。
函数内通过赋值语句定义的变量自动进入 Local 作用域。注意:即使变量在函数末尾才被赋值,只要在函数体内出现赋值操作(包括 +=、append 等),该变量即被视为 Local,即使其在外部已定义同名变量。
反例:误判 Local 导致 UnboundLocalError
x = 100
def test():
print(x) # ❌ 报错:UnboundLocalError
x = 200
test()
原因:函数内出现 x = 200,解释器将 x 视为 Local 变量;但 print(x) 执行时,Local 中的 x) 尚未绑定值,故报错。
适用于闭包场景。外层函数的局部变量对内层函数构成 Enclosing 作用域。
正例:闭包访问外层变量
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
c = make_counter()
print(c()) # 1
print(c()) # 2
此处 count 定义于 make_counter(Enclosing 层),counter(Local 层)需用 nonlocal 声明才能修改它。
模块顶层定义的变量属于 Global 作用域。函数内访问 Global 变量无需声明;但若要修改,则必须显式使用 global 关键字。
包含所有内置函数、异常、常量(如 True、False、None)。可通过 dir(__builtins__) 查看全部内置名称。
⚠️ 避免覆盖内置名!例如定义 list = [1,2,3] 后,原 list() 函数将被遮蔽,导致后续代码异常。
这两个关键字用于显式声明变量所属作用域,是修改非 Local 变量的唯一合法途径。
语法:global var_name,声明后可在函数内修改模块级变量。
正例:正确使用 global 修改全局变量
counter = 0
def increment():
global counter
counter += 1
increment()
print(counter) # 1
注意:global 仅对当前函数有效,不影响其他函数;且不能用于类属性或模块级容器内部元素(如 global config['key'] 非法)。
语法:nonlocal var_name,仅用于嵌套函数中,指向最近一层非全局的外层作用域变量。
正例:闭包中修改 Enclosing 层变量
def outer():
x = 10
def inner():
nonlocal x
x = 20
print("inner:", x)
inner()
print("outer:", x)
outer()
# 输出:
# inner: 20
# outer: 20
⚠️ 错误用法:nonlocal 不能用于修改 Global 或 Built-in 变量;若外层无该变量名,将抛出 SyntaxError。
变量声明即赋值,引用即访问其指向对象。Python 不要求显式声明类型,但需先赋值再引用。
# 正确示例
name = "Alice"
print(name) # Alice
# 错误示例:未定义就引用
# print(age) # ❌ NameError: name 'age' is not defined
注意:变量名区分大小写,Name 与 name 是不同变量。
常见错误:在函数内修改列表等可变对象时误以为“未改变作用域”
items = [1, 2, 3]
def add_item():
items.append(4) # ✅ 允许!修改对象内容不改变绑定关系
add_item()
print(items) # [1, 2, 3, 4]
# 但以下操作会触发作用域冲突:
def replace_items():
items = [5, 6] # ❌ 创建新 Local 变量,覆盖全局引用
replace_items()
print(items) # 仍为 [1, 2, 3, 4]
关键理解:赋值操作(=)创建新绑定,而 append、extend 等方法仅修改对象内部状态,不涉及绑定关系变更。
闭包会“捕获”外层变量的引用,而非值拷贝。这导致一个经典陷阱:
funcs = []
for i in range(3):
funcs.append(lambda: i)
print([f() for f in funcs]) # [2, 2, 2] 而非 [0, 1, 2]
原因:所有 lambda 共享同一个 i 引用,循环结束时 i=2,故全部返回 2。
✅ 正确写法:通过默认参数绑定当前值
funcs = []
for i in range(3):
funcs.append(lambda x=i: x) # 默认参数在定义时求值
print([f() for f in funcs]) # [0, 1, 2]
类中变量分三类,调用方式截然不同:
| 类型 | 定义位置 | 调用方式 | 特点 |
|---|---|---|---|
| 实例变量 | __init__ 中 self.var | obj.var | 每个对象独立副本 |
| 类变量 | 类体内直接定义 | Class.var 或 obj.var | 所有实例共享 |
| 静态变量 | 使用 @staticmethod 定义方法内局部变量 | 方法内调用 | 无类/实例绑定 |
反例:误将类变量当实例变量
class Counter:
count = 0 # 类变量
def __init__(self):
self.count = 0 # ❌ 实例变量覆盖类变量!应移除此行
def inc(self):
Counter.count += 1 # ✅ 正确修改类变量
c1 = Counter()
c2 = Counter()
c1.inc()
print(Counter.count) # 1
print(c1.count) # 0 ← 实例变量遮蔽了类变量
真相:仅读取全局变量无需声明;修改必须用 global 显式声明。否则会创建同名 Local 变量,导致逻辑错误。
列表、字典等可变对象的原地修改(如 append、update)不触发作用域变更;但重新赋值(=)会创建新 Local 变量。
循环中创建闭包时,必须通过默认参数显式绑定当前值,否则所有闭包共享最终值。
locals() / globals() 查看当前作用域变量字典dir() 查看对象可用属性与方法id(obj) 验证是否为同一对象引用locals().keys() 观察 Local 作用域范围user_name 而非 un),禁用内置名(list、str)typing 模块增强可读性与IDE支持反例:全局变量滥用
config = {"debug": True}
def process(data):
if config["debug"]:
print("Debug:", data)
return data
✅ 推荐:显式传递依赖
def process(data, debug=False):
if debug:
print("Debug:", data)
return data
相同点:两者均支持词法作用域;不同点在于:
var 具有函数作用域,而 let/ const 具有块级作用域;Python 仅函数、类、模块构成作用域边界var 声明的变量可被提升(hoisting);Python 无变量提升,未定义即报错global 显式声明当实例属性与类属性同名时,实例属性优先级更高。访问顺序为:实例字典 → 类字典 → 父类字典。
示例:
class A:
x = 1
a = A()
a.x = 2 # 创建实例属性
print(a.x) # 2 ← 实例属性覆盖类属性
del a.x
print(a.x) # 1 ← 回退至类属性
不推荐动态创建变量(如 globals()[f"var_{i}"] = i),易导致命名污染。推荐使用字典或列表代替:
# 不推荐
for i in range(3):
globals()[f"var_{i}"] = i * 10
# 推荐
vars_dict = {f"var_{i}": i * 10 for i in range(3)}
若覆盖内置名(如 list = [1,2]),内置函数将不可用。解决方法:
del list 删除自定义变量,恢复内置名list_ 或 items_list 等命名Python 使用引用计数作为主要内存管理方式。变量绑定时计数+1,解除绑定(del、作用域结束)时计数-1;当计数归零,对象立即销毁。
示例:
a = [1, 2, 3] # 列表引用计数 = 1
b = a # 计数 = 2
del a # 计数 = 1
del b # 计数 = 0 → 对象销毁
当对象间存在循环引用(如双向链表),引用计数无法归零。此时 Python 启用 gc 模块的分代回收器扫描并清理。
检测循环引用:
import gc
gc.set_debug(gc.DEBUG_SAVEALL)
gc.collect()
变量声明即创建引用,绑定对象;作用域边界决定其可见范围
通过变量名访问对象;受 LEGB 规则约束;修改操作触发作用域检查
作用域结束或显式 del 时解除绑定;引用计数归零则对象销毁
| 术语 | 定义 | 示例 |
|---|---|---|
| 命名空间 | 变量名到对象的映射表 | globals() 返回模块级命名空间 |
| 作用域链 | LEGB 四层作用域组成的查找路径 | 内层函数通过作用域链访问外层变量 |
| 闭包 | 函数 + 其捕获的外层变量环境 | 返回的函数对象携带 Enclosing 作用域 |
| 可变/不可变对象 | 对象是否可原地修改 | 列表(可变)vs 字符串(不可变) |
| 浅拷贝 vs 深拷贝 | 对象复制时的嵌套层级处理 | copy.copy() vs copy.deepcopy() |