<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="深入讲解作用域局部变量全局变量global关键字的核心内容与关键技术，属于Python编程基础的函数与模块方向">
<title>作用域：局部变量、全局变量、global关键字 函数与模块 Python编程基础-AI全栈-AIQZ.CC</title>
<link rel="icon" type="image/svg+xml" href="/favicon.svg">
<link rel="stylesheet" href="/css/chapter.css?v=20260612e">
<link rel="stylesheet" href="/vendor/katex/katex.min.css">
<script src="/vendor/katex/katex.min.js"></script>
<script src="/vendor/katex/auto-render.min.js"></script>
</head>
<body>
<div class="app-container">
  <aside class="left-sidebar" id="leftSidebar">
    <div class="sidebar-content">
      <nav class="nav-section">
        <div class="nav-header">课程目录</div>
        <!--#include virtual="/ssi/nav/course-nav.html" -->
      </nav>
    </div>
  </aside>
  <main class="main-content">
    <article class="content-area">
      <h1>作用域：局部变量、全局变量、global关键字</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>变量的&quot;作用域&quot;（Scope）决定了代码中哪些地方可以访问和修改这个变量。Python 遵循 <strong>LEGB 规则</strong>（Local → Enclosing → Global → Built-in），从内到外逐层查找变量。<strong>局部变量</strong>只在函数内部可见，函数执行完就销毁；<strong>全局变量</strong>在整个模块内可见，但函数内部要修改它需要用 <code>global</code> 关键字声明。你可以把作用域想象成公司的楼层权限——你自己的工位（局部作用域）想怎么布置都行，别人的工位你看得到但不能碰，公司大堂的公告板（全局作用域）所有人都能看，但修改公告需要特殊权限（<code>global</code> 声明）。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①LEGB 规则决定了 Python 查找变量的顺序：局部 → 闭包 → 全局 → 内置 ②函数内部定义的变量是局部变量，只在函数内有效，函数外访问会报 NameError ③在函数顶部用 <code>global 变量名</code> 声明后，函数内可以修改全局变量 ④嵌套函数中修改外层变量用 <code>nonlocal</code> 关键字 ⑤全局变量应该尽量少用——它们让代码难以理解和调试</blockquote>


<h2>教学与演示</h2>
<h3>一、局部变量——函数内部的&quot;私人空间&quot;</h3>
<p><strong>是什么</strong>：局部变量（Local Variable）是在<strong>函数内部定义</strong>的变量。它的生存周期和函数调用绑定——函数开始执行时创建，执行结束时销毁。外部代码无法访问函数内部的局部变量，这是 Python 的作用域隔离机制。函数参数也属于局部变量——它们只在函数执行期间存在。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 局部变量就像你在自己家里（函数内部）摆放的家具——你想怎么布置就怎么布置，外人从窗口看不见也碰不着。你离开家（函数执行完），家具自动消失（变量销毁）。每次重新回家（再次调用函数），家具会重新&quot;变出来&quot;（变量重新创建）。不同人的家之间完全独立——你家的沙发和别人家的一模一样也没关系，各管各的。</blockquote>


<p><strong>为什么</strong>：局部变量的隔离性是一把双刃剑——它在保护我们。好处：①防止函数间的变量名冲突——10 个函数里都可以有 <code>x</code> 变量，互不影响；②内存高效——函数执行完自动回收内存，不残留垃圾；③代码可读性——看到变量就知道它只在当前函数内使用。在 AI 中，训练循环里的 <code>epoch_loss</code>、<code>batch_data</code>、<code>gradients</code> 都是局部变量，一次迭代用完就释放，不污染命名空间。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 没有局部作用域的世界会怎样？两个人合租，没有人有&quot;私人空间&quot;——A 把自己袜子放在（全局变量）<code>drawer</code> 里，B 把自己袜子也放在（同一个全局变量）<code>drawer</code>——结果 A 找袜子时发现里面是 B 的袜子。这就是全局变量的噩梦。局部变量解决了这个问题——给你一个只属于你的抽屉。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><code class="language-python">import numpy as np

# ====== 1. 局部变量的基本行为 ======

def my_function():
    &quot;&quot;&quot;函数内部的所有赋值都创建局部变量&quot;&quot;&quot;
    x = 100                                    # x 是局部变量
    y = &quot;hello&quot;                                # y 也是局部变量
    print(f&quot;  函数内部: x = {x}, y = {y}&quot;)
    return x + 1

# 调用函数，内部打印局部变量
my_function()

# 尝试在外部访问局部变量——会报错
try:
    print(x)                                   # NameError: name 'x' is not defined
except NameError as e:
    print(f&quot;外部访问局部变量失败: {e}&quot;)        # 局部变量在函数外不可见！

# ====== 2. 参数也是局部变量 ======

def double(n):                                 # n 是参数（局部变量）
    result = n * 2                             # result 也是局部变量
    return result

output = double(5)
# print(n) ❌ NameError——参数 n 也是局部的！
# print(result) ❌ NameError
print(f&quot;\ndouble(5) 返回: {output}&quot;)           # 10 — 但返回值可以赋给外部变量

# ====== 3. 不同函数中同名局部变量互不影响 ======

def func_a():
    count = 10                                 # func_a 的局部 count
    print(f&quot;  func_a 中 count = {count}&quot;)
    return count

def func_b():
    count = 20                                 # func_b 的局部 count（和 func_a 无关！）
    print(f&quot;  func_b 中 count = {count}&quot;)
    return count

print(f&quot;\nfunc_a 返回: {func_a()}&quot;)            # 10
print(f&quot;func_b 返回: {func_b()}&quot;)              # 20
# 两个 count 就像住在不同城市中的两个&quot;张三&quot;——名字一样，但完全是不同的人

# ====== 4. 参数修改不影响外部变量（不可变类型） ======

def increment(n):
    &quot;&quot;&quot;尝试修改参数——不会影响外部变量&quot;&quot;&quot;
    n = n + 1                                  # 修改局部变量 n 的指向
    print(f&quot;  函数内部 n = {n}&quot;)

original = 10
increment(original)
print(f&quot;\noriginal 仍然是: {original}&quot;)        # 10 — 没变！

# ====== 5. AI 场景：训练循环中的局部变量 ======

def train_one_epoch(model_weights, data, learning_rate):
    &quot;&quot;&quot;模拟一个 epoch 的训练——所有变量都是局部的&quot;&quot;&quot;
    # model_weights、data、learning_rate 都是局部参数

    total_loss = 0.0                           # 局部变量：累计损失
    num_batches = 0                            # 局部变量：批次数

    for batch in data:                         # batch 是局部循环变量
        # 前向传播（模拟）
        predictions = batch * model_weights    # 局部变量
        # 计算损失（模拟）
        loss = np.mean((predictions - batch * 1.5) ** 2)  # 局部变量
        total_loss += loss
        num_batches += 1

        # 反向传播更新权重（模拟）
        grad = 2 * (predictions - batch * 1.5) * batch     # 局部变量：梯度
        model_weights = model_weights - learning_rate * grad # 局部更新

    avg_loss = total_loss / max(num_batches, 1)  # 局部变量：平均损失
    return model_weights, avg_loss               # 返回更新后的权重和损失

# 模拟数据
fake_data = [np.array([1.0]), np.array([2.0]), np.array([0.5]), np.array([1.5])]
weights = np.array([0.8])                        # 初始权重（外部变量）

print(&quot;\n=== 模拟训练 ===&quot;)
print(f&quot;训练前权重: {weights[0]:.4f}&quot;)

new_weights, loss = train_one_epoch(weights, fake_data, 0.01)
print(f&quot;训练后权重: {new_weights[0]:.4f}&quot;)      # 权重被函数修改了（通过返回值）
print(f&quot;平均损失: {loss:.6f}&quot;)
print(f&quot;外部 weights: {weights[0]:.4f}&quot;)        # 原始权重没变（因为 numpy 是可变但函数内重新赋值的）</code></pre><p><strong>什么用</strong>：局部作用域是编写可靠 AI 代码的基础。训练循环中的 <code>loss</code>、<code>accuracy</code>、<code>batch_x</code>、<code>batch_y</code> 都是局部变量——如果它们是全局的，同时训练两个模型就会互相干扰。数据预处理函数 <code>normalize(data)</code> 内部的 <code>mean</code>、<code>std</code> 是局部变量，不会泄露到外部。PyTorch 中 <code>with torch.no_grad():</code> 创建了一个作用域，内部的操作不会记录梯度——这也是作用域思想的延伸。记住：<strong>能用局部变量解决的问题，就不要用全局变量</strong>。</p>
<h3>二、全局变量——模块级别的&quot;公共空间&quot;</h3>
<p><strong>是什么</strong>：全局变量（Global Variable）是在<strong>函数外部</strong>（模块顶层）定义的变量。它们在整个模块（.py 文件）内可见——函数内部可以<strong>读取</strong>全局变量的值（但不能直接修改）。全局变量的生命周期和程序一致——从模块加载到程序退出，一直存在。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 全局变量就像城市广场上的公告牌——所有市民（函数）都能看到上面写了什么，但不能随便涂改（要改需要 <code>global</code> 许可证）。好处是信息共享方便——所有函数都能获取同一份配置数据；坏处是人多了就容易踩脚——谁都可以&quot;看&quot;，容易造成&quot;谁改了我的变量？&quot;的困惑。</blockquote>


<p><strong>为什么</strong>：全局变量有它的适用场景——但不是&quot;因为方便所以到处用&quot;。合理的使用场景：①<strong>配置常量</strong>（如 <code>BATCH_SIZE = 32</code>、<code>MODEL_PATH = &quot;/data/models/&quot;</code>），程序启动时设定，运行中不修改；②<strong>跨函数共享的状态</strong>（如训练计数器 <code>global_step</code>），只有少数地方修改。不合理的用法：把大量数据、中间结果、临时变量都定义成全局的——这会让代码变成&quot;意大利面条&quot;，bug 极难追踪。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 适量用全局变量就像你家小区公示栏——贴个物业通知、停水告示，大家都方便。滥用全局变量就像把每一件私人物品都堆在小区广场——手机、钱包、内衣裤都摆出来——不是不能这么干，但小偷（bug）方便了，你也找不着东西了。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-2"><code class="language-python">import numpy as np

# ====== 1. 全局变量的定义和读取 ======

# 这两个是全局变量——定义在函数外面
MODEL_NAME = &quot;SimpleCNN&quot;                       # 全局常量（约定：大写命名）
training_epoch = 0                             # 全局状态变量

def show_config():
    &quot;&quot;&quot;函数内部可以读取全局变量&quot;&quot;&quot;
    print(f&quot;模型名称: {MODEL_NAME}&quot;)           # 读取全局变量 ✅
    print(f&quot;当前轮次: {training_epoch}&quot;)       # 读取全局变量 ✅

show_config()

# ====== 2. 尝试在函数内部修改全局变量——会创建局部变量！ ======

def try_modify():
    &quot;&quot;&quot;这个函数试图修改全局变量——但实际创建了同名的局部变量&quot;&quot;&quot;
    training_epoch = 100                       # ⚠️ 这不是修改全局变量！是创建局部变量！
    MODEL_NAME = &quot;ResNet&quot;                      # ⚠️ 同理，创建了局部变量 MODEL_NAME
    print(f&quot;  函数内部: training_epoch = {training_epoch}&quot;)
    print(f&quot;  函数内部: MODEL_NAME = {MODEL_NAME}&quot;)

print(f&quot;\n调用前: training_epoch = {training_epoch}, MODEL_NAME = {MODEL_NAME}&quot;)
try_modify()
# 外部没有改变！
print(f&quot;调用后: training_epoch = {training_epoch}, MODEL_NAME = {MODEL_NAME}&quot;)
# training_epoch 还是 0，MODEL_NAME 还是 &quot;SimpleCNN&quot;！

# ====== 3. 用 global 关键字真正修改全局变量 ======

def really_modify():
    &quot;&quot;&quot;用 global 关键字声明后，修改的就是全局变量&quot;&quot;&quot;
    global training_epoch                      # 声明：我要修改全局的 training_epoch
    global MODEL_NAME                          # 声明：我要修改全局的 MODEL_NAME

    training_epoch = 100                       # 现在是修改全局变量了！
    MODEL_NAME = &quot;ResNet-50&quot;                   # 现在是修改全局变量了！

print(f&quot;\n使用 global 前: training_epoch = {training_epoch}, MODEL_NAME = {MODEL_NAME}&quot;)
really_modify()
print(f&quot;使用 global 后: training_epoch = {training_epoch}, MODEL_NAME = {MODEL_NAME}&quot;)

# ====== 4. global 可以同时声明和修改 ======

counter = 0                                    # 全局计数器

def increment_counter():
    &quot;&quot;&quot;递增全局计数器——每次调用 +1&quot;&quot;&quot;
    global counter                             # 声明要修改全局的 counter
    counter += 1
    return counter

print(f&quot;\n初始 counter: {counter}&quot;)
for i in range(5):
    print(f&quot;  第 {i+1} 次调用: {increment_counter()}&quot;)
print(f&quot;最终 counter: {counter}&quot;)              # 5

# ====== 5. 修改可变全局对象——不需要 global ======

# 重要！如果全局变量是可变对象（列表、字典），修改其内容不需要 global
global_log = []                                # 全局日志列表

def add_log(entry):
    &quot;&quot;&quot;向全局日志添加记录——不需要 global！&quot;&quot;&quot;
    # 注意：这里没写 global global_log，但修改成功
    # 因为我们不是&quot;重新赋值 global_log 变量&quot;，而是&quot;修改它引用的对象&quot;
    global_log.append(entry)
    print(f&quot;  日志已添加({len(global_log)}条): {entry}&quot;)

add_log(&quot;模型初始化完成&quot;)
add_log(&quot;数据加载完成&quot;)
add_log(&quot;训练开始&quot;)
print(f&quot;\n全局日志: {global_log}&quot;)

# ⚠️ 但如果要把 global_log 指向一个新列表，就需要 global
def reset_log():
    &quot;&quot;&quot;重置日志——这需要 global，因为要改变 global_log 变量指向的对象&quot;&quot;&quot;
    global global_log
    global_log = []                             # 让 global_log 指向新列表

reset_log()
print(f&quot;重置后日志: {global_log}&quot;)             # []

# ====== 6. AI 场景：全局训练配置 ======

# 合理使用全局变量的场景：程序级配置常量
RANDOM_SEED = 42                               # 全局随机种子
DEVICE = &quot;cpu&quot;                                 # 全局设备配置
LOG_INTERVAL = 100                             # 每隔多少步打印一次日志

def set_seed():
    &quot;&quot;&quot;使用全局随机种子初始化&quot;&quot;&quot;
    np.random.seed(RANDOM_SEED)                # 读取全局配置
    return np.random.rand(3)                   # 使用种子的随机数

def train_step(step_count):
    &quot;&quot;&quot;模拟训练步骤——根据全局配置决定是否打印日志&quot;&quot;&quot;
    if step_count % LOG_INTERVAL == 0:         # 读取全局 LOG_INTERVAL
        print(f&quot;  [Step {step_count}] 当前设备: {DEVICE}&quot;)

print(f&quot;\n=== 全局配置训练 ===&quot;)
print(f&quot;随机种子={RANDOM_SEED}, 设备={DEVICE}, 日志间隔={LOG_INTERVAL}&quot;)
set_seed()
train_step(100)                                # 打印（100 % 100 == 0）
train_step(150)                                # 不打印（150 % 100 != 0）
train_step(200)                                # 打印</code></pre><p><strong>什么用</strong>：在 AI 项目中，全局常量（<code>BATCH_SIZE</code>、<code>LEARNING_RATE</code>、<code>NUM_EPOCHS</code>、<code>DATA_PATH</code>）是全局变量的合理应用。它们通常定义在配置文件或脚本开头，整个项目都能读取，但运行时不会修改。PyTorch Lightning 的 <code>Trainer</code> 内部就使用了全局的 <code>rank</code> 变量来管理分布式训练的设备信息。但要警惕把&quot;偶尔方便&quot;变成&quot;习惯&quot;——全局变量的可维护性成本会随着项目规模指数增长。</p>
<h3>三、nonlocal 关键字——修改外层函数的变量</h3>
<p><strong>是什么</strong>：<code>nonlocal</code> 关键字用于<strong>嵌套函数</strong>中——当内部函数想修改外层（Enclosing）函数的变量时，用 <code>nonlocal</code> 声明。它和 <code>global</code> 的区别是：<code>global</code> 跳到模块顶层，<code>nonlocal</code> 只跳到最近的外层函数。<code>nonlocal</code> 不能用于模块顶层的变量（那里没有外层函数）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 如果把作用域想象成三层楼——一楼是全局变量（所有人公用），二楼是你家（外层函数），三楼是你自己的房间（内层函数）。你在三楼房间里想要修改二楼客厅的东西，得喊一声 <code>nonlocal</code>——&quot;这个东西是外面客厅的！&quot;。如果你直接喊 <code>global</code>，就像跳过了二楼直接去一楼找——找错了地方。</blockquote>


<p><strong>为什么</strong>：<code>nonlocal</code> 主要用于<strong>闭包</strong>（Closure）场景——内部函数需要&quot;记住&quot;并修改外层状态时。最典型的例子是计数器工厂：外层函数创建一个 <code>count</code> 变量，内层函数每次被调用时 <code>count += 1</code>。这是比全局变量优雅得多的状态管理方式——每个计数器有自己独立的状态，多个计数器不会互相干扰。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 没有 <code>nonlocal</code> 的世界：你要写一个计数器，只能把计数变量放在全局——<code>global_counter = 0</code>。问题来了——你想有两个独立的计数器 A 和 B，各计各的。全局变量做不到这一点（只有一个 <code>global_counter</code>）。<code>nonlocal</code> 解决了这个问题——通过闭包，每个计数器有自己的&quot;私有计数变量&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-3"><code class="language-python">import numpy as np

# ====== 1. nonlocal 的基本用法 ======

def outer():
    &quot;&quot;&quot;外层函数&quot;&quot;&quot;
    x = &quot;外层变量&quot;                              # 外层函数的局部变量

    def inner():
        &quot;&quot;&quot;内层函数——想修改外层的 x&quot;&quot;&quot;
        nonlocal x                             # 声明：我要修改外层的 x！
        x = &quot;内层修改了&quot;                        # 真正修改了外层变量
        print(f&quot;  内层中 x = {x}&quot;)

    print(f&quot;调用内层前: x = {x}&quot;)
    inner()
    print(f&quot;调用内层后: x = {x}&quot;)              # 外层 x 被改了！

outer()

# ====== 2. 没有 nonlocal 时的行为——创建局部变量 ======

def outer_without():
    &quot;&quot;&quot;演示没有 nonlocal 会怎样&quot;&quot;&quot;
    count = 0                                  # 外层变量

    def inner():
        # 没有 nonlocal 声明
        count = 999                            # 这创建了 inner 自己的局部 count！
        print(f&quot;  内层局部 count = {count}&quot;)

    inner()
    print(f&quot;外层 count 仍然是: {count}&quot;)       # 0 — 没变！

outer_without()

# ====== 3. nonlocal vs global——区别对比 ======

g = &quot;全局变量&quot;                                  # 模块级全局变量

def test_scope():
    e = &quot;外层变量&quot;                              # 外层函数局部变量

    def inner():
        nonlocal e                             # 跳一层：找外层函数的 e
        global g                               # 跳到顶：找模块级的 g
        e = &quot;修改外层&quot;                          # 改了 test_scope 的 e
        g = &quot;修改全局&quot;                          # 改了模块级的 g
        print(f&quot;  内层: e={e}, g={g}&quot;)

    print(f&quot;内层调用前: e={e}, g={g}&quot;)
    inner()
    print(f&quot;内层调用后: e={e}, g={g}&quot;)

print(f&quot;test_scope 调用前: g={g}&quot;)
test_scope()
print(f&quot;test_scope 调用后: g={g}&quot;)

# ====== 4. 闭包计数器——nonlocal 的经典应用 ======

def make_counter(initial=0):
    &quot;&quot;&quot;创建一个计数器函数——每个计数器有独立的状态&quot;&quot;&quot;
    count = initial                            # 外层变量（每个闭包独有一份）

    def counter():
        &quot;&quot;&quot;每次调用计数 +1，返回当前计数&quot;&quot;&quot;
        nonlocal count                         # 声明修改外层的 count
        count += 1
        return count

    return counter                              # 返回内部函数

# 创建两个独立的计数器
counter_a = make_counter()                     # A 从 0 开始
counter_b = make_counter(100)                  # B 从 100 开始

print(f&quot;\n=== 独立计数器 ===&quot;)
print(f&quot;A: {counter_a()}, B: {counter_b()}&quot;)   # A: 1, B: 101
print(f&quot;A: {counter_a()}, B: {counter_b()}&quot;)   # A: 2, B: 102
print(f&quot;A: {counter_a()}&quot;)                     # A: 3 — B 不受影响
print(f&quot;A: {counter_a()}, B: {counter_b()}&quot;)   # A: 4, B: 103
# 两个计数器完全独立！这就是 nonlocal + 闭包的威力

# ====== 5. AI 场景：带状态记忆的早停机制 ======

def make_early_stopping(patience=5, min_delta=0.001):
    &quot;&quot;&quot;创建早停检查器——内部用 nonlocal 维护状态&quot;&quot;&quot;
    best_loss = float(&quot;inf&quot;)                   # 外层：最优损失
    wait_count = 0                             # 外层：等待次数

    def check(current_loss):
        &quot;&quot;&quot;每次调用检查是否应该早停&quot;&quot;&quot;
        nonlocal best_loss, wait_count         # 声明修改外层变量

        if current_loss &lt; best_loss - min_delta:
            best_loss = current_loss           # 更新最优损失
            wait_count = 0                     # 重置等待计数
            print(f&quot;  ✅ Loss 改善: {best_loss:.4f} (重置等待)&quot;)
            return False                        # 不早停
        else:
            wait_count += 1                    # 等待 +1
            print(f&quot;  ⏳ Loss 未改善: 等待 {wait_count}/{patience}&quot;)
            if wait_count &gt;= patience:
                print(f&quot;  🛑 早停触发！最优 Loss: {best_loss:.4f}&quot;)
                return True                    # 触发早停
            return False                       # 继续等待

    return check

# 模拟训练过程中的损失值
early_stop_check = make_early_stopping(patience=3, min_delta=0.01)
epoch_losses = [0.85, 0.72, 0.70, 0.71, 0.69, 0.70, 0.70, 0.71]

print(&quot;\n=== 早停机制演示 ===&quot;)
for epoch, loss in enumerate(epoch_losses):
    print(f&quot;Epoch {epoch+1}: Loss={loss:.2f}&quot;, end=&quot; → &quot;)
    if early_stop_check(loss):
        break                                   # 早停触发，停止训练</code></pre><p><strong>什么用</strong>：<code>nonlocal</code> 在 AI 中用于创建有状态的工具函数。早停（Early Stopping）检查器用闭包维护最优损失和等待计数；学习率调度器用闭包记录当前步数和初始学习率；梯度累积器用闭包累加多个 batch 的梯度。PyTorch 的 <code>nn.Module</code> 注册钩子（hooks）时，经常用闭包来捕获中间激活值用于可视化或调试——这都是 <code>nonlocal</code> 的威力所在。</p>
<h3>四、LEGB 规则——Python 找变量的完整逻辑</h3>
<p><strong>是什么</strong>：LEGB 是 Python 查找变量时的四层作用域规则：<strong>L</strong>ocal（局部，函数内部）→ <strong>E</strong>nclosing（闭包，外层函数）→ <strong>G</strong>lobal（全局，模块级别）→ <strong>B</strong>uilt-in（内置，Python 自带的名字）。当你在代码中引用一个变量时，Python 按这个顺序逐层向上查找，找到第一个匹配的就停止。如果四层都找不到，报 <code>NameError</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> LEGB 规则就像找东西的流程：先在自己口袋里找（Local）→ 没找到去客厅找（Enclosing）→ 还没找到去小区公告栏看（Global）→ 最后去市政府查档案（Built-in）。Python 不会跳过任何一步——口袋里有手机（局部变量叫 <code>max</code>），你喊 <code>max()</code> 想用内置函数，结果找到的是你口袋里的——悲剧了。</blockquote>


<p><strong>为什么</strong>：理解 LEGB 规则能帮你避免最隐蔽的 bug。最常见的错误是&quot;变量遮蔽&quot;（Variable Shadowing）——你不小心定义了一个和内置函数同名的局部变量，导致内置函数不可用。或者你以为是全局变量，实际访问的是外层函数的局部变量。LEGB 规则解释了所有&quot;为什么变量找不到/找错了&quot;的疑惑。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 你写 <code>max([1,2,3])</code> 发现报错 <code>TypeError: &#39;int&#39; object is not callable</code>——疯了，<code>max</code> 怎么可能不是函数？排查半天发现前面某处写了 <code>max = 100</code>（局部变量覆盖了内置函数 max）。这就是 LEGB 规则——局部优先级高于内置。破解方法：给 IDE 装个 linter，它会提醒你&quot;不要用内置函数名做变量名&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np

# ====== 1. LEGB 规则演示 ======

# B: Built-in —— Python 内置的名字
# print, len, max, range 等都是 Built-in

# G: Global —— 模块级变量
x_global = &quot;我是全局变量&quot;

def outer_function():
    # E: Enclosing —— 外层函数局部变量
    x_enclosing = &quot;我是外层变量&quot;

    def inner_function():
        # L: Local —— 内层函数局部变量
        x_local = &quot;我是局部变量&quot;

        # 查找 x_local：先在 Local 找 → 找到了！
        print(f&quot;查找 x_local: {x_local}&quot;)
        # 查找 x_enclosing：Local 没有 → Enclosing 找到了！
        print(f&quot;查找 x_enclosing: {x_enclosing}&quot;)
        # 查找 x_global：Local 没有 → Enclosing 没有 → Global 找到了！
        print(f&quot;查找 x_global: {x_global}&quot;)
        # 查找 len：四层都没有 → Built-in 找到了！
        print(f&quot;内置函数 len: {len([1, 2, 3])}&quot;)

    inner_function()

outer_function()

# ====== 2. 变量遮蔽（Variable Shadowing）——常见陷阱 ======

print(&quot;\n=== 变量遮蔽陷阱 ===&quot;)

# Python 内置的 max 函数
print(f&quot;正常的 max: {max([3, 1, 4, 1, 5])}&quot;)   # 5

# ⚠️ 在局部作用域定义了和内置函数同名的变量
def broken_function():
    max = 100                                  # ❌ 覆盖了内置的 max！
    # max([1, 2, 3]) ❌ TypeError: 'int' object is not callable
    print(f&quot;  max 现在是 {max}（不是函数了！）&quot;)

broken_function()

# 全局遮蔽！
# list = [1, 2, 3]  ❌ 千万别这样写！list 是内置类
# 解决办法：用 del 恢复
# del list  ← 恢复内置的 list

# ✅ 好的命名习惯：用描述性名称，不覆盖内置名
my_max_value = 100                             # 不是 max，不冲突
my_list = [1, 2, 3]                            # 不是 list，不冲突

# ====== 3. 函数内部读取全局变量的 LEGB 路径 ======

count = 42                                     # Global

def has_local_shadow():
    count = 100                                # Local: 遮蔽了全局 count
    print(f&quot;  有局部遮蔽: count = {count}&quot;)    # 100 — 先找到局部的

def no_local():
    print(f&quot;  没有局部: count = {count}&quot;)      # 42 — Local 没有，往上找到 Global

print(&quot;\n=== LEGB 查找路径 ===&quot;)
has_local_shadow()
no_local()

# ====== 4. AI 场景：用 LEGB 规则理解训练函数的数据流 ======

# 全局配置
BATCH_SIZE = 32
LEARNING_RATE = 0.01

def train_model(dataset):
    &quot;&quot;&quot;训练模型——变量作用域的最佳实践示范&quot;&quot;&quot;
    # dataset 是局部参数
    # BATCH_SIZE 和 LEARNING_RATE 从 Global 读取

    model_params = np.array([0.5])             # 局部：模型参数
    epoch_losses = []                          # 局部：记录各 epoch 损失

    def train_epoch(epoch_data):
        &quot;&quot;&quot;内层函数：训练一个 epoch&quot;&quot;&quot;
        # epoch_data 是局部参数
        nonlocal model_params                   # 修改外层 model_params

        total_loss = 0.0
        for batch in epoch_data:               # batch 是局部循环变量
            # 前向传播（模拟）
            pred = batch * model_params
            # 计算损失
            loss = (pred - batch * 1.5) ** 2
            total_loss += loss[0]
            # 梯度更新（读取全局 LEARNING_RATE）
            model_params = model_params - LEARNING_RATE * 2 * (pred - batch * 1.5)

        return total_loss / len(epoch_data)

    for epoch in range(5):                     # epoch 是局部循环变量
        loss = train_epoch(dataset)
        epoch_losses.append(round(loss, 4))

    return model_params, epoch_losses

# 模拟数据集
data = [np.array([x]) for x in [1.0, 2.0, 0.5, 1.5, 2.5]]
final_params, losses = train_model(data)

print(f&quot;\n=== 训练结果 ===&quot;)
print(f&quot;最终参数: {final_params[0]:.4f}&quot;)
print(f&quot;各 epoch 损失: {losses}&quot;)
print(f&quot;BATCH_SIZE 仍然: {BATCH_SIZE}&quot;)        # 全局变量没有被修改
print(f&quot;LEARNING_RATE 仍然: {LEARNING_RATE}&quot;)  # 全局变量没有被修改</code></pre><p><strong>什么用</strong>：LEGB 规则不仅仅是一个概念——它解释了你在训练脚本中遇到的几乎所有变量访问问题。为什么 <code>lambda</code> 函数里能访问到外部的 <code>learning_rate</code>？因为 Enclosing 作用域。为什么 <code>global_step</code> 能在所有函数里读取？因为 Global 作用域。当你在 Jupyter Notebook 中不小心覆盖了 <code>sum</code>、<code>list</code> 这些内置函数时，也是因为 LEGB 规则——局部变量优先于 Built-in。理解 LEGB，就理解了 Python 变量查找的全部秘密。</p>
<div class="demo-embed" data-demo-src="/demos/variables-demo1.html"><a href="/demos/variables-demo1.html">作用域探索者——LEGB 规则的视觉之旅（动画演示）</a></div>


<h2>概念关系图谱</h2>
<div class="table-wrapper"><table class="concept-map-table"><thead><tr><th>概念</th><th>核心含义</th><th>与AI的关系</th><th>关联概念</th></tr></thead><tbody><tr><td>局部变量</td><td>函数内部定义，仅函数内可见</td><td>训练循环中的临时变量、batch数据</td><td>作用域、生命周期</td></tr><tr><td>全局变量</td><td>模块顶层定义，全模块可读</td><td>配置常量、随机种子、设备信息</td><td>global、模块</td></tr><tr><td>global</td><td>函数内声明用以修改全局变量</td><td>跨函数共享状态计数器</td><td>nonlocal、赋值</td></tr><tr><td>nonlocal</td><td>内层函数中用以修改外层函数变量</td><td>早停检查器、学习率调度器</td><td>global、闭包</td></tr><tr><td>LEGB</td><td>变量查找的四层规则</td><td>理解AI代码中数据流的关键</td><td>作用域链、变量遮蔽</td></tr><tr><td>闭包</td><td>内层函数记住外层变量的机制</td><td>工厂函数创建独立状态</td><td>nonlocal、高阶函数</td></tr><tr><td>变量遮蔽</td><td>内层变量名覆盖外层同名变量</td><td>小心覆盖内置函数如list/max</td><td>LEGB、命名规范</td></tr><tr><td>可变全局对象</td><td>修改全局可变对象内容不需global</td><td>全局日志列表、指标收集</td><td>global、赋值vs修改</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: 为什么函数内部修改全局变量需要 <code>global</code>，但读取不需要？</h3>
<p>Python 的设计哲学是&quot;读取默认安全，写入需要显式授权&quot;。读取全局变量不会造成破坏——看看公告牌不会改变任何东西。但写入会影响整个程序的全局状态，可能导致难以追踪的 bug，所以 Python 要求你必须显式声明 <code>global</code>——相当于你说&quot;我知道这会改变全局状态，我有意为之&quot;。Python 还做了一个特殊处理：如果函数内部对某变量赋值，Python 就认为它是局部变量——这就是 <code>x = 100</code> 创建局部 <code>x</code> 而不是修改全局 <code>x</code> 的原因。</p>
<h3>Q2: <code>nonlocal</code> 和 <code>global</code> 的核心区别是什么？</h3>
<p><strong>跳转目标不同。</strong> <code>global</code> 直接跳到模块顶级——不管嵌套了多少层，<code>global x</code> 找的一定是模块全局的那个 <code>x</code>。<code>nonlocal</code> 只跳到最近的外层函数——如果有三层嵌套，<code>nonlocal x</code> 找的是上一层的 <code>x</code>（如果上一层没有，再往上一层找，直到找到非全局的 <code>x</code>）。另一个区别：<code>global</code> 可以在任何函数中使用（即使没有嵌套）；<code>nonlocal</code> 只能在嵌套函数中使用（因为必须有&quot;外层&quot;可跳）。</p>
<h3>Q3: 如果全局变量是列表，为什么 <code>global_list.append(x)</code> 可以修改内容而不需要 <code>global</code>？</h3>
<p>因为 <code>global</code> 控制的是&quot;变量名指向哪个对象&quot;，而不是&quot;对象的内部状态如何&quot;。<code>global_list.append(x)</code> 没有改变 <code>global_list</code> 这个变量指向哪个列表——它指向的还是同一个 <code>list</code> 对象，只是这个 <code>list</code> 的内容变了。Python 的 LEGB 规则控制的是<strong>变量名解析</strong>，而不是<strong>对象修改</strong>。反过来，如果你想 <code>global_list = []</code>（让变量指向一个全新的空列表），这就改变了变量名的指向，必须用 <code>global</code> 声明。</p>
<h3>Q4: 什么是&quot;变量遮蔽&quot;（Shadowing）？如何避免？</h3>
<p>变量遮蔽是指内层作用域定义了和外层同名的变量，导致外层变量在内层&quot;不可见&quot;——被挡住了。最常见的危险情况是覆盖内置函数名：<code>list = [1,2,3]</code> 之后就不能用 <code>list()</code> 构造函数了。避免方法：①记住 Python 内置函数名（<code>list</code>、<code>dict</code>、<code>sum</code>、<code>max</code>、<code>min</code>、<code>id</code>、<code>type</code>、<code>input</code> 等），不拿来当变量名；②用更具体的命名：<code>my_list</code> 而不是 <code>list</code>，<code>max_value</code> 而不是 <code>max</code>；③IDE 通常会高亮警告内置函数被覆盖。</p>
<h3>Q5: 在 AI 训练中，什么时候该用全局变量，什么时候该用类属性？</h3>
<p><strong>最简单的判断标准：是否只有一个实例。</strong> 如果整个程序只需要一个训练配置（最常见情况），用全局常量（大写命名）就够了。如果需要多个模型同时训练、各有独立的状态，则应该用类封装——每个模型实例有自己的属性。比如 <code>model.learning_rate</code> 是实例属性，比全局 <code>LEARNING_RATE</code> 更适合多模型场景。在实践中，AI 项目通常混合使用——全局常量用于程序级配置，类属性用于模型级状态。</p>

<h2>章节单词汇总</h2>
<div class="vocab-table-wrapper"><table class="vocab-table"><thead><tr><th>英文</th><th>音标</th><th>术语/释义</th></tr></thead><tbody><tr><td>scope</td><td>/skoʊp/</td><td>作用域；变量可见的范围</td></tr><tr><td>local</td><td>/ˈloʊkəl/</td><td>局部的；函数内部定义且仅内部可见</td></tr><tr><td>global</td><td>/ˈɡloʊbəl/</td><td>全局的；模块顶层定义，全模块可见</td></tr><tr><td>nonlocal</td><td>/nɒnˈloʊkəl/</td><td>非局部的；用于嵌套函数修改外层变量</td></tr><tr><td>LEGB</td><td>/el iː dʒiː biː/</td><td>四层作用域查找规则</td></tr><tr><td>closure</td><td>/ˈkloʊʒər/</td><td>闭包；内层函数记住外层变量的机制</td></tr><tr><td>shadowing</td><td>/ˈʃædoʊɪŋ/</td><td>遮蔽；内层变量名覆盖外层同名变量</td></tr><tr><td>enclosing</td><td>/ɪnˈkloʊzɪŋ/</td><td>外层的；嵌套函数中包围内层的外层函数</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下代码输出什么？<code>x = 10; def f(): x = 20; f(); print(x)</code></h3>
<ul>
<li>A. 20</li><li>B. 10</li><li>C. 报错</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。函数内部的 <code>x = 20</code> 创建了局部变量 <code>x</code>，不影响全局的 <code>x</code>。所以 <code>print(x)</code> 输出全局的 10。如果想修改全局 x，函数内需要 <code>global x</code>。</blockquote>


<h3>Q2 [单选] LEGB 规则中，Python 查找变量的正确顺序是？</h3>
<ul>
<li>A. Built-in → Global → Enclosing → Local</li><li>B. Global → Local → Enclosing → Built-in</li><li>C. Local → Enclosing → Global → Built-in</li><li>D. Local → Global → Enclosing → Built-in</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。LEGB = Local → Enclosing → Global → Built-in。从最内层向外层查找，Built-in 优先级最低（所以能被局部变量遮蔽）。</blockquote>


<h3>Q3 [单选] 以下代码输出什么？<code>lst = [1]; def f(): lst.append(2); f(); print(lst)</code></h3>
<ul>
<li>A. <code>[1, 2]</code></li><li>B. <code>[1]</code></li><li>C. 报错</li><li>D. <code>[2]</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>lst.append(2)</code> 没有改变 <code>lst</code> 变量指向哪个对象——它只是在修改同一个列表对象的内容。所以不需要 <code>global</code> 声明，全局列表的内容被修改了。</blockquote>


<h3>Q4 [多选] 以下关于 <code>global</code> 关键字说法正确的是？</h3>
<ul>
<li>A. 在函数内部使用 <code>global x</code> 后可以修改全局变量 x</li><li>B. <code>global</code> 声明必须放在对变量的第一次使用之前</li><li>C. 如果全局变量是不可变类型，函数内可以直接用 <code>+=</code> 修改</li><li>D. <code>global</code> 可以同时声明多个变量：<code>global x, y, z</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——不管什么类型，<code>+=</code> 在函数内部都会尝试创建局部变量（除非有 <code>global</code> 声明）。D 正确，<code>global a, b, c</code> 一行声明多个。</blockquote>


<h3>Q5 [单选] 嵌套函数中，如何修改外层函数的变量？</h3>
<ul>
<li>A. 用 <code>global</code></li><li>B. 直接赋值</li><li>C. 用 <code>nonlocal</code></li><li>D. 无法修改</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>nonlocal</code> 专门用于嵌套函数中修改外层（Enclosing）函数的变量。<code>global</code> 会跳到模块级，不是外层函数。</blockquote>


<h3>Q6 [多选] 哪些是合理使用全局变量的场景？</h3>
<ul>
<li>A. 程序级配置常量：<code>BATCH_SIZE = 32</code></li><li>B. 随机种子：<code>SEED = 42</code></li><li>C. 训练循环的临时损失值</li><li>D. 文件路径常量：<code>DATA_DIR = &quot;/data/datasets/&quot;</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确——这些都是程序级配置，定义一次、运行中不修改。C 错误——损失值是临时的、每个 epoch 变化的，应该用局部变量或返回值。</blockquote>


<h3>Q7 [单选] <code>max = 5; print(max([1, 2, 3]))</code> 会怎样？</h3>
<ul>
<li>A. 输出 5</li><li>B. 输出 3</li><li>C. 报错 TypeError</li><li>D. 输出 [1, 2, 3]</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>max = 5</code> 让 <code>max</code> 从内置函数变成了一个整数。接着 <code>max([1,2,3])</code> 试图把整数当函数调用——<code>TypeError: &#39;int&#39; object is not callable</code>。这是典型的变量遮蔽陷阱。</blockquote>


<h3>Q8 [多选] 关于函数参数的变量作用域，以下正确的是？</h3>
<ul>
<li>A. 函数参数是函数的局部变量</li><li>B. 函数内部对参数的重新赋值不影响外部实参（不可变类型时）</li><li>C. 参数默认是全局变量</li><li>D. 参数的生命周期和函数调用绑定</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。参数在函数内部是局部变量，函数执行完就销毁。C 错误——参数是局部变量，不是全局的。</blockquote>


<h3>Q9 [单选] 以下代码输出什么？<code>x = 10; def f(): global x; x = 20; def g(): x = 30; g(); f(); print(x)</code></h3>
<ul>
<li>A. 10</li><li>B. 20</li><li>C. 30</li><li>D. 报错</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。执行顺序：<code>x=10</code>（全局）→ <code>g()</code> 中 <code>x=30</code> 创建局部变量（不影响全局）→ <code>f()</code> 中 <code>global x; x=20</code> 修改全局 → <code>print(x)</code> 输出 20。注意 <code>g()</code> 没有 <code>global</code> 声明，所以 <code>x=30</code> 是局部变量。</blockquote>


<h3>Q10 [多选] 关于 LEGB 规则，以下说法正确的是？</h3>
<ul>
<li>A. <code>Built-in</code> 是最后一层查找，优先级最低</li><li>B. 在函数内部直接赋值会在 Local 层创建变量</li><li>C. 外层函数的变量在内层函数中可以直接修改</li><li>D. <code>nonlocal</code> 沿作用域链向外查找，直到找到非全局的变量</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——内层函数不能直接修改外层函数的变量，需要 <code>nonlocal</code> 声明。直接赋值会在内层创建同名的局部变量（遮蔽）。</blockquote>


</div>

      <div class="content-actions">
        <button class="action-btn" onclick="sharePage()" title="分享">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"/><polyline points="16 6 12 2 8 6"/><line x1="12" y1="2" x2="12" y2="15"/></svg><span>分享</span>
        </button>
        <button class="action-btn" onclick="printPage()" title="打印">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 6 2 18 2 18 9"/><path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/></svg><span>打印</span>
        </button>
        <button class="action-btn" onclick="showFeedback()" title="反馈">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg><span>反馈</span>
        </button>
      </div>
    </article>
  </main>
</div>

<script type="application/json" id="formula-data">{}</script>
<script type="application/json" id="quiz-data">[
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。函数内部的 `x = 20` 创建了局部变量 `x`，不影响全局的 `x`。所以 `print(x)` 输出全局的 10。如果想修改全局 x，函数内需要 `global x`。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。LEGB = Local → Enclosing → Global → Built-in。从最内层向外层查找，Built-in 优先级最低（所以能被局部变量遮蔽）。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`lst.append(2)` 没有改变 `lst` 变量指向哪个对象——它只是在修改同一个列表对象的内容。所以不需要 `global` 声明，全局列表的内容被修改了。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——不管什么类型，`+=` 在函数内部都会尝试创建局部变量（除非有 `global` 声明）。D 正确，`global a, b, c` 一行声明多个。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`nonlocal` 专门用于嵌套函数中修改外层（Enclosing）函数的变量。`global` 会跳到模块级，不是外层函数。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确——这些都是程序级配置，定义一次、运行中不修改。C 错误——损失值是临时的、每个 epoch 变化的，应该用局部变量或返回值。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`max = 5` 让 `max` 从内置函数变成了一个整数。接着 `max([1,2,3])` 试图把整数当函数调用——`TypeError: 'int' object is not callable`。这是典型的变量遮蔽陷阱。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。参数在函数内部是局部变量，函数执行完就销毁。C 错误——参数是局部变量，不是全局的。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。执行顺序：`x=10`（全局）→ `g()` 中 `x=30` 创建局部变量（不影响全局）→ `f()` 中 `global x; x=20` 修改全局 → `print(x)` 输出 20。注意 `g()` 没有 `global` 声明，所以 `x=30` 是局部变量。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——内层函数不能直接修改外层函数的变量，需要 `nonlocal` 声明。直接赋值会在内层创建同名的局部变量（遮蔽）。"
  }
]</script>

<script src="/js/chapter-enhance.js"></script>
<script src="/js/pay-modal.js?v=20260606e"></script>
<script src="/js/chapter-common.js"></script>
<script src="/js/chapter-learn.js"></script>
<script src="/js/chapter-nav.js"></script>
<script src="/js/chapter-voice.js"></script>
<script src="/js/chapter-quiz.js"></script>
<script src="/js/chapter-presence.js"></script>
<script src="/js/chapter-auth.js"></script>
<script src="/js/chapter-code.js"></script>
<script src="/js/chapter-annotation.js"></script>
<script src="/js/chapter-comments.js"></script>
<script src="/js/chapter-social.js"></script>
<script src="/js/chapter-ui.js?v=20260612c"></script>
<script src="/js/chapter-init.js?v=20260612b"></script>
</body>
</html>