深入理解 Python 的 nonlocal 关键字_石家庄创泽智能科技有限公司

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

深入理解 Python 的 nonlocal 关键字

2025-11-22

浏览次数：次

返回列表

深入理解 python 的 nonlocal 关键字

nonlocal 关键字用于在嵌套函数中修改其外层（非全局）作用域中的变量。它解决了在内层函数中对外部变量进行赋值操作时，Python 默认创建局部变量的问题，确保了对预期变量的直接修改。本文将详细阐述 nonlocal 的作用机制、适用场景，并与 global 关键字进行对比，辅以代码示例，帮助开发者清晰掌握其使用方法。

Python 作用域基础

在深入理解 nonlocal 之前，我们需要回顾 Python 的作用域规则。Python 遵循 LEGB 规则：Local (局部)、Enclosing (闭包或外层)、Global (全局)、Built-in (内置)。

局部作用域 (Local)：函数内部定义的变量，只在该函数内部可见。
外层作用域 (Enclosing)：在一个函数内部定义另一个函数时，外部函数的局部作用域对于内部函数来说就是外层作用域。
全局作用域 (Global)：模块级别定义的变量，在整个模块中可见。
内置作用域 (Built-in)：Python 内置的函数和常量（如 print, len, True 等）。

当 Python 解释器在函数内部遇到一个变量名时，它会首先在局部作用域中查找。如果找不到，它会依次向外层作用域、全局作用域和内置作用域查找。如果一个变量在函数内部被赋值，Python 默认会将其视为一个局部变量，除非显式声明。

nonlocal 关键字的作用

nonlocal 关键字主要用于解决一个特定问题：当内层函数需要修改其外层（非全局）作用域中的变量时。如果没有 nonlocal 声明，内层函数对该变量的赋值操作将默认创建一个新的局部变量，而不是修改外层作用域中的同名变量。

nonlocal 的核心功能是： 允许内层函数直接修改其直接外层（非全局）作用域中的变量，使其赋值操作作用于外层变量本身，而不是在内层函数中创建一个新的局部变量。

何时需要使用 nonlocal

当满足以下两个条件时，你需要使用 nonlocal：

你正在一个嵌套函数（或闭包）的内部。
你希望在内层函数中对一个外层作用域（但非全局作用域）的变量进行重新赋值操作。

让我们通过一个具体的例子来理解：

def outer_function():
    count = 0 # 这是外层作用域的变量

    def inner_function():
        # 如果不使用 nonlocal，这里的 count = 10 会创建一个新的局部变量 count
        # nonlocal count # 启用这行，则会修改外层作用域的 count
        count = 10
        print(f"Inner function: count = {count}")

    inner_function()
    print(f"Outer function: count = {count}")

outer_function()
# 输出：
# Inner function: count = 10
# Outer function: count = 0 (如果 nonlocal count 被注释)
# Outer function: count = 10 (如果 nonlocal count 被启用)

在上述代码中，如果 nonlocal count 被注释掉，inner_function 内部的 count = 10 会创建一个新的局部变量 count。因此，outer_function 打印的 count 仍然是 0。只有当 nonlocal count 被启用时，inner_function 才能修改 outer_function 中的 count 变量。

nonlocal 与 global 的区别

nonlocal 和 global 都用于在函数内部修改外部变量，但它们针对的作用域不同：

CA.LA

第一款时尚产品在线设计平台，服装设计系统

94 查看详情 CA.LA

global 关键字：用于声明一个变量是全局作用域中的变量。这意味着对该变量的任何赋值操作都将修改全局变量，而不是创建局部变量。
nonlocal 关键字：用于声明一个变量是外层（非全局）作用域中的变量。这意味着对该变量的任何赋值操作都将修改最近的外层变量，而不是创建局部变量。

简而言之，global 穿透所有层级直达全局作用域，而 nonlocal 只作用于直接外层（非全局）作用域。

global_var = 100

def outer_scope():
    enclosing_var = 200

    def inner_scope():
        local_var = 300

        # 修改全局变量
        global global_var
        global_var += 1

        # 修改外层作用域变量
        nonlocal enclosing_var
        enclosing_var += 1

        print(f"Inside inner_scope: global_var={global_var}, enclosing_var={enclosing_var}, local_var={local_var}")

    inner_scope()
    print(f"Inside outer_scope: global_var={global_var}, enclosing_var={enclosing_var}")

outer_scope()
print(f"Outside all functions: global_var={global_var}")

# 预期输出：
# Inside inner_scope: global_var=101, enclosing_var=201, local_var=300
# Inside outer_scope: global_var=101, enclosing_var=201
# Outside all functions: global_var=101

何时不需要使用 nonlocal (结合示例分析)

回到最初的问题场景，为什么在 LeetCode 问题的递归解法中，即使内层 dfs 函数修改了 visited 集合，却不需要 nonlocal 呢？

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        res = []
        adjList = defaultdict(list)
        visited = set() # 外层作用域的 visited 变量

        # ... (构建图的逻辑)

        def dfs(curr, path):
            if curr in visited: # 读取 visited
                return True
            # ...
            path.remove(curr)
            visited.add(curr) # 修改 visited 集合的内容
            res.append(curr) # 修改 res 列表的内容
            return True

        # ... (拓扑排序逻辑)

在这个例子中，visited 是一个 set 对象，res 是一个 list 对象。这两种都是可变对象。

关键在于：nonlocal 仅在尝试对变量本身进行重新赋值时才需要。当你调用可变对象的方法（如 set.add()、list.append()、dict.update() 等）来修改其内容时，你并没有重新绑定变量名到另一个对象，因此不需要 nonlocal。变量 visited 仍然指向内存中的同一个 set 对象，只是这个 set 对象的内容发生了变化。

例如：

def outer():
    my_list = [] # my_list 指向一个空的列表对象

    def inner():
        my_list.append(1) # 修改了 my_list 指向的列表对象的内容，不是重新赋值 my_list
        # 如果是 my_list = [1, 2]，这就需要 nonlocal 了

    inner()
    print(my_list) # 输出: [1]
outer()

在这个例子中，inner 函数通过 my_list.append(1) 修改了 outer 作用域中 my_list 变量所引用的列表对象的内容，但它并没有改变 my_list 变量本身所引用的对象。因此，nonlocal 在这里是不需要的。