第 17 章 代码的邻里关系:变量作用域
📖 本章目标:分清局部变量和全局变量,理解
global,吃透 LEGB 查找顺序。
学完本章,你就不会再困惑"为什么函数里改了变量,外面没变"这种鬼问题了。
变量也有"户口"——出生在哪里,就归哪里管。搞清楚这套户口制度,你的函数才会像一栋好房子:房间独立,互不串门,但村里的公共设施照样能用。
【开场小剧场】村里的冰箱
学生: 皮皮,我昨天写了个函数,在里面改了外面的变量,可运行完发现外面没变,气死我了。
皮皮: 因为你家冰箱和村里超市是两回事。函数里创建的变量,是函数自己家的东西(局部变量);函数外面定义的变量,是村里的公共设施(全局变量)。
学生: 那我能在函数里用村里的东西吗?
皮皮: 用可以(读),改不行(写)——除非你申请一张 global 许可证。今天就把这套"邻里规矩"讲透。
学生: 等等,那要是我在屋里摆了个和村里同名的冰箱,是算我的还是算村里的?
皮皮: (拍桌)问到点子上了!这就是"同名遮蔽"——近水楼台先得月,你屋里的先用你屋里的。 今天全给你理清楚。
17.1 局部变量:函数里的私人物品
在函数内部创建的变量,叫局部变量。它只在这个函数里有效,函数一结束就"销毁"了,外面想用都找不到:
def make_fruit():
fruit = "苹果" # 局部变量,只属于这个函数
print("函数里:", fruit)
make_fruit()
print(fruit) # ❌ 报错:NameError:'fruit' is not defined
运行结果:
函数里: 苹果
Traceback (most recent call last):
...
NameError: name 'fruit' is not defined
逐行拆解:
- def make_fruit()::定义函数;
- fruit = "苹果":fruit 在函数内部创建 → 它是局部变量,户口在函数家;
- print("函数里:", fruit):在函数里读自己的局部变量,正常;
- print(fruit)(函数外):函数已经结束,fruit 已经被"处理掉"了,外面访问直接 NameError。
为什么外面访问不到? 因为 fruit 是函数"自己家的冰箱",函数结束了,冰箱也关门了,外面自然拿不到。局部变量跟着函数的生命走:函数在,它在;函数亡,它亡。
换例加深:两个函数可以各用各的同名变量
def fun_a():
i = 1
print("A 里的 i:", i)
def fun_b():
i = 2
print("B 里的 i:", i)
fun_a() # A 里的 i: 1
fun_b() # B 里的 i: 2
两个函数里的 i 是两个不同的箱子,互不打扰。这就是局部变量的好处——你在函数里用 i、temp、result 这种烂大街的名字,想怎么用怎么用,完全不用担心撞车。
🐍"皮皮注:这就是'局部'的意思——只在局部(函数内部)有效。它保护了函数的独立性:写大程序时,十几个函数里全是
i也不乱,因为谁家的i归谁家管。"
易错提醒: 不要在函数外试图访问函数里的局部变量——那是人家的私人物品,NameError 伺候。
配套代码文件:code/ch17/scope_demo.py。
17.2 全局变量:村里的公共设施
在函数外面(模块顶层)定义的变量,叫全局变量,整个程序都能读到:
country = "中国" # 全局变量
def show():
print("我在", country) # 函数里可以读全局变量
show() # 我在 中国
print(country) # 中国
逐行拆解:
- country = "中国":写在所有函数外面 → 全局变量,全村共用的"公告栏";
- def show(): 里的 print("我在", country):读全局,合法;
- show() 和函数外的 print(country):都能正常输出。
注意:读可以,写不行。 看这个经典坑:
❌ 错误示范(想改全局变量):
count = 10
def add_one():
count = count + 1 # 报错:UnboundLocalError
print(count)
add_one()
运行结果:
Traceback (most recent call last):
...
UnboundLocalError: local variable 'count' referenced before assignment
为什么报错? 因为 count = count + 1 里的 count = 会让 Python 认为"你在创建一个新的局部变量 count",于是右边的 count 也被当成局部变量——但它还没定义,于是报"局部变量未绑定"。
一句话总结:函数里只要对某个名字赋值了,它就被当成局部变量,哪怕外面有个同名的全局变量。
语法格式(能改全局的方式):
global 变量名 # 在函数里先声明,再修改
易错提醒: 报错信息 UnboundLocalError 一出现,第一反应就该是"函数里想改全局变量,忘了 global"。这不是玄学,规则就一条:赋值 = 认定局部。
17.3 同名遮蔽:近水楼台先得月
函数里定义的变量,和全局变量同名时,函数里用的是自己的(局部优先),这叫遮蔽(shadowing):
name = "全局皮皮" # 全局变量
def show():
name = "局部皮皮" # 局部变量,同名但不同
print("函数里:", name)
show()
print("函数外:", name)
运行结果:
函数里: 局部皮皮
函数外: 全局皮皮
逐行拆解:
- 全局层:name = "全局皮皮",村里的公告栏;
- 函数里 name = "局部皮皮":这是创建局部变量,不是修改全局;
- print("函数里:", name):函数里查名字 → 先查自己家 → 找到局部 name,输出"局部皮皮";
- print("函数外:", name):在函数外 → 读的是全局 name,输出"全局皮皮"。
函数里的 name 和外面的 name 是两个不同的箱子,只是碰巧都叫 name。函数里访问的是自己家的,外面的安然无恙。
换例加深:遮蔽只在你赋值之后才开始
x = "全局"
def f():
print(x) # 此刻还没赋值 → 读全局
x = "局部" # 从这一行开始,x 变成局部变量
print(x) # 现在读局部
f()
注意这个隐蔽的坑! 在 x = "局部" 之前,x 还是全局的,所以第一个 print(x) 输出"全局";但第二个 print(x) 输出"局部"。而且千万别反过来写:
x = "全局"
def f():
print(x) # ❌ UnboundLocalError!
x = "局部"
f()
等等,为什么这次报错了? 因为 Python 是"先看完整函数再执行"的:它扫到函数体里有 x = "局部",就认定整个函数里 x 都是局部变量。于是第一行 print(x) 里的 x 也按局部算——但还没赋值,直接报 UnboundLocalError。想读全局,就从头到尾别对同名变量赋值。
💡 遮蔽本身不是错,但别故意写同名变量——会让人困惑"到底用的是哪个"。好的习惯:函数参数和局部变量,起名避免和全局变量撞车。
17.4 global:申请修改全局
真的要在函数里修改全局变量怎么办?用 global 声明:"这个变量我用的是全村那个,不是我自己家新的":
count = 10
def add_one():
global count # 声明:count 是全局变量
count = count + 1
add_one()
print(count) # 11,真的改了!
add_one()
print(count) # 12
运行结果:
11
12
逐行拆解:
- global count:这是申请许可证——"我要用的 count 是全村那个,别给我造局部的";
- count = count + 1:有了许可证,这一行改的就是全局变量;
- 两次 add_one(),全局 count 从 10 → 11 → 12。
语法格式:
def 函数名():
global 变量名 # 放在函数体开头
变量名 = 新值 # 之后就可以改全局了
经典用途:计数器。 比如记录"这个函数被调用了多少次":
calls = 0
def ring():
global calls
calls += 1
print(f"第 {calls} 次按铃")
ring()
ring()
ring()
运行结果:
第 1 次按铃
第 2 次按铃
第 3 次按铃
换例加深:多个全局一起声明
a = 0
b = 0
def reset():
global a, b # 一次声明多个
a = 0
b = 0
配套代码文件:code/ch17/counter.py。
🐍"皮皮注:global 能用,但别滥用。函数一旦大量依赖 global,代码就像一团互相拉扯的毛线,很难看懂。正确姿势:能传参数就传参数,能用 return 就用 return——global 是最后的手段。皮皮的座右铭:'少用 global,多用 return。'"
易错提醒: global 声明必须在赋值之前写。写成 count = count + 1 之后再补 global count 是没用的,照样报 UnboundLocalError。
17.5 作用域查找顺序:LEGB
Python 在函数里找变量时,按下面顺序一层层找,找到就停:
- L 局部(Local):函数内部;
- E 嵌套(Enclosing):外层函数(第 27 章讲闭包时会用到);
- G 全局(Global):模块顶层;
- B 内置(Built-in):Python 自带的(
print、len这些)。
x = "全局x" # G 全局
def outer(): # 这个函数包含内层函数(为演示嵌套作用域)
x = "嵌套x" # E 嵌套层
def inner():
x = "局部x" # L 局部
print(x)
inner()
outer() # 输出 局部x(局部优先)
运行结果:
局部x
逐行拆解:
- x = "全局x":G 层,村里的公告栏;
- outer() 里 x = "嵌套x":E 层,这是 outer 这个"家"的局部变量;
- inner() 里 x = "局部x":L 层,inner 自己家的;
- inner() 里 print(x):按 L→E→G→B 顺序找,先在自己家(L)找到了,就用它,输出"局部x"。
如果 inner 里没有 x 呢? 那就往上:在 E 层找到"嵌套x"→ 输出"嵌套x"。再没有?找 G 层。再没有?找 B 层(内置)。都没有?报 NameError。
换例加深:看看嵌套层怎么被读到
x = "全局"
def outer():
x = "嵌套"
def inner():
print(x) # inner 自己没定义 x → 找 E 层 → 嵌套
inner()
outer() # 嵌套
规则一句话:从内往外找,先碰到的算谁的。
💡 记个口诀:"里面没有往外看,谁先找到用谁的。" LEGB 就是这条规则的分层版本。你现在用到最多的是 L 和 G,但知道 E 和 B 的存在,以后读复杂代码就不慌了。
【皮皮小课堂】本章要点
- 局部变量:函数里创建的,函数结束就没了,外面访问不到。
- 全局变量:模块顶层定义的,整个程序能读。
- 写 vs 读:函数里读全局 OK,写全局要
global声明。 - 同名遮蔽:函数里定义了同名变量,用的是自己的,不影响全局。
- 赋值 = 认定局部:只要函数里对某个名字赋值,它就从那刻起变成局部变量。
global x:声明"x 用的是全局那个",然后才能修改它。- LEGB 查找顺序:局部 → 嵌套 → 全局 → 内置。
- 少用 global,多用 return。
【翻车现场】本章的坑
坑 1:函数里给全局变量赋值 → UnboundLocalError
count = 10
def f():
count = count + 1 # ❌ UnboundLocalError
一赋值,count 就被当成局部变量。要用 global count 声明(见 17.4)。
坑 2:以为函数里改了外部变量
x = 5
def f():
x = 10 # 创建的是局部 x,不是改全局!
f()
print(x) # 还是 5
没写 global 就只是创建了一个局部变量,全局 x 纹丝不动。想改外面的,记得 global。
坑 3:global 声明写在赋值之后
count = 10
def f():
count = count + 1 # ❌ 已经报错了
global count # ❌ 这才声明,晚了!
global 声明必须在赋值之前。Python 编译函数时按"扫到 global 才算"处理,声明写后面等于没写。
坑 4:滥用 global,代码变毛线团
到处 global 改一堆变量,程序的状态你根本管不过来。能用参数和返回值解决,就别 global。 函数该是"输入 → 输出"的干净黑盒子,别让它偷偷改外面的世界。
坑 5:以为"读了又赋值"就安全
x = "全局"
def f():
print(x) # ❌ UnboundLocalError
x = "局部"
f()
Python 先扫完整个函数:只要后面有 x = ...,前面的 print(x) 里的 x 也按局部算,还没赋值就报错。想读全局,就别在同一函数里对它赋值。
坑 6:遮蔽同名,自己绕晕
name = "皮皮"
def show():
name = "皮皮" # 你以为在"重新设置"全局 name?
print(name) # 输出的却是局部
show()
print(name) # 全局还是原来的
遮蔽不是错误,但容易造成"我以为改了,其实没改"的错觉。 好的习惯:局部变量别和全局撞名,实在要撞,想清楚自己到底想操作哪一个。
【本章习题】
一、选择题
1. (★) 运行下面代码,输出结果是?
x = 5
def f():
x = 10
print(x)
f()
print(x)
- A.
5和10 - B.
10和5 - C.
10和10 - D.
5和5
2. (★★) 运行下面代码,输出结果是?
x = 5
def f():
global x
x = 10
f()
print(x)
- A.
5 - B.
10 - C. 报错
- D.
None
3. (★★) 下面代码会怎样?
n = 1
def f():
n = n + 1
f()
- A. 正常运行,全局 n 变成 2
- B. 报错
UnboundLocalError - C. 正常运行,全局 n 不变
- D. 报错
NameError
4. (★★) 运行下面代码,输出结果是?
x = "全局"
def f():
print(x)
x = "局部"
print(x)
f()
- A. 全局、局部
- B. 局部、局部
- C. 报错
UnboundLocalError - D. 全局、全局
5. (★★ 多选) 关于作用域,下列说法正确的是?
- A. 函数里可以读全局变量
- B. 函数里不写
global,对同名的赋值创建的是局部变量 - C. 局部变量在函数结束后仍然存在
- D.
global声明后才能修改全局变量
二、判断题
1. (★) 在函数里创建局部变量,函数结束后该变量就消失了。( )
2. (★★) 函数里不能读取全局变量。( )
3. (★★) 只要函数里对某个名字赋了值,这个名字就被当作局部变量。( )
4. (★★) LEGB 中,L 代表局部、B 代表内置。( )
三、代码纠错题
1. (★★) 下面的代码想统计函数被调用的次数,但运行报错,请指出问题并改正:
calls = 0
def ring():
calls = calls + 1
print(f"第 {calls} 次")
ring()
2. (★★) 下面的代码,学生以为会输出两次"局部",但报错了,请指出原因并改正:
x = "全局"
def f():
print(x)
x = "局部"
print(x)
f()
四、编程实战题
1. (基础 ★) 写一个函数 show_city(),函数里创建一个局部变量 city = "上海" 并打印;在函数外也定义一个 city = "北京"。调用函数后,分别打印函数内外,观察结果。
2. (基础 ★★) 用 global 写一个"取款机余额"模拟:全局变量 balance = 1000,写一个函数 withdraw(money) 扣钱,一个函数 show_balance() 显示余额。调用几次观察余额变化。
3. (基础 ★★) 写一个函数 guess_scope():函数外定义 fruit = "苹果",函数内不赋值直接打印 fruit(观察能读到全局);再写一个函数 guess_shadow(),函数内赋值 fruit = "香蕉" 再打印(观察遮蔽)。运行两个函数,解释输出。
4. (挑战 ★★★) 猜输出题:运行下面代码,说出每行输出的结果,并解释为什么:
x = "G"
def outer():
x = "E"
def inner():
print(x)
inner()
outer()
【参考答案与解析】
一、选择题
1. 答案:B
函数里 x = 10 创建了局部 x(遮蔽全局),f() 打印局部 x = 10;函数外打印全局 x = 5。
2. 答案:B
global x 声明后,函数里改的是全局变量,x 变成 10。
3. 答案:B
函数里对 n 赋值,n 被当作局部变量;但 n = n + 1 右边的 n 还没定义,报 UnboundLocalError。
4. 答案:C
Python 先扫完整个函数:发现 x = "局部",认定全函数里 x 是局部变量。于是第一个 print(x) 读的是还没赋值的局部 x → UnboundLocalError。想读全局,就别在函数里对同名变量赋值。
5. 答案:A、B、D
A 对:可以读全局;B 对:赋值就变成局部; C 错:局部变量函数结束就销毁;D 对:修改全局需 global 声明。
二、判断题
1. 正确(√)。局部变量生命周期只到函数结束。
2. 错误(×)。函数里可以读全局变量,只是不能直接改。
3. 正确(√)。只要函数里赋值,该名字就按局部处理(即使它曾经是全局)。
4. 正确(√)。LEGB:Local、Enclosing、Global、Built-in。
三、代码纠错题
1. 解析: calls = calls + 1 里的 calls 被当作局部变量,但右边还没定义 → UnboundLocalError。改正:加 global calls:
calls = 0
def ring():
global calls
calls = calls + 1
print(f"第 {calls} 次")
ring() # 第 1 次
ring() # 第 2 次
2. 解析: 函数里后面有 x = "局部",Python 认定 x 全程是局部变量,第一个 print(x) 就报 UnboundLocalError。如果想第一个打印全局、第二个打印局部,应该换掉局部变量的名字:
x = "全局"
def f():
print(x) # 全局
x2 = "局部"
print(x2) # 局部
f()
不要在同一函数里"先读全局、再创建同名局部"——Python 会从扫到赋值那刻起,把整个函数里该名字都当局部,前面的读直接报错。
四、编程实战题
1. 参考代码:
city = "北京" # 全局
def show_city():
city = "上海" # 局部,遮蔽全局
print("函数里:", city)
show_city() # 函数里: 上海
print("函数外:", city) # 函数外: 北京
2. 参考代码:
balance = 1000
def withdraw(money):
global balance
if money > balance:
print("余额不足!")
return
balance -= money
print(f"取出 {money},成功!")
def show_balance():
print(f"当前余额:{balance} 元")
show_balance() # 1000
withdraw(300) # 取出 300
show_balance() # 700
withdraw(99999) # 余额不足!
show_balance() # 700
3. 参考代码:
fruit = "苹果"
def guess_scope():
print("函数里读到:", fruit) # 没赋值 → 读全局
def guess_shadow():
fruit = "香蕉"
print("函数里:", fruit) # 局部遮蔽 → 香蕉
guess_scope() # 函数里读到: 苹果(读了全局)
guess_shadow() # 函数里: 香蕉(局部遮蔽)
print("函数外:", fruit) # 函数外: 苹果(全局没被改)
解析: guess_scope 里没给 fruit 赋值,所以读的是全局"苹果";guess_shadow 里赋值了,创建局部"香蕉",遮蔽全局;但全局 fruit 始终是"苹果"。
4. 答案与解析:
E
解析: outer() 里创建了局部变量 x = "E"。inner() 里没有定义 x,于是按 LEGB 从内往外找:局部(inner 里没有)→ 嵌套层(outer 里的 x="E")→ 找到,输出 E。这就是"嵌套作用域"的作用——它也是第 27 章"闭包"的地基。
🐍"皮皮注:这题的 L-E-G-B 走位很经典。你要是能答对,作用域就算出师了。顺带一提,上一章学的
return、这一章学的global加一起,你写函数已经可以'进可攻退可守'了。"
📖 下一章,函数版的套娃——递归。让函数自己调用自己。