函数 · 让代码长成模块

第17章 代码的邻里关系

变量作用域

第 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 在函数里找变量时,按下面顺序一层层找,找到就停:

  1. L 局部(Local):函数内部;
  2. E 嵌套(Enclosing):外层函数(第 27 章讲闭包时会用到);
  3. G 全局(Global):模块顶层;
  4. 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 的存在,以后读复杂代码就不慌了。


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 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)

2. (★★) 运行下面代码,输出结果是?

x = 5

def f():
    global x
    x = 10

f()
print(x)

3. (★★) 下面代码会怎样?

n = 1

def f():
    n = n + 1

f()

4. (★★) 运行下面代码,输出结果是?

x = "全局"

def f():
    print(x)
    x = "局部"
    print(x)

f()

5. (★★ 多选) 关于作用域,下列说法正确的是?

二、判断题

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 加一起,你写函数已经可以'进可攻退可守'了。"


📖 下一章,函数版的套娃——递归。让函数自己调用自己。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)