闭包(closure)不是一种新的数据类型,而是一种函数关系:一个函数定义在另一个函数内部,并且引用了外层函数的变量。即使外层函数已经执行结束,内部函数仍然可以使用那些变量。
可以把它理解成「函数和它需要的环境一起被保存下来」。下面的 make_greeting() 执行后返回了内部函数 greet(),返回的函数仍然记得当时传入的 language:
make_greeting()
greet()
language
01def make_greeting(language): 02 def greet(name): 03 return f"{language},{name}!" 04 05 return greet 06 07say_hello = make_greeting("你好") 08say_morning = make_greeting("早上好") 09 10print(say_hello("小明")) # 你好,小明! 11print(say_morning("小红")) # 早上好,小红!
make_greeting() 返回的不是问候语字符串,而是一个函数。每次调用 make_greeting() 都会创建一份独立的外层变量,因此 say_hello 和 say_morning 互不影响。
say_hello
say_morning
内部函数读取外层函数的变量时,就形成了闭包。这个变量也叫「自由变量」:它不是内部函数的参数,也不是内部函数里新定义的局部变量,但内部函数仍然能够访问它。
01def make_multiplier(factor): 02 def multiply(number): 03 return number * factor 04 05 return multiply 06 07double = make_multiplier(2) 08triple = make_multiplier(3) 09 10print(double(5)) # 10 11print(triple(5)) # 15
调用 make_multiplier(2) 时,factor 的值被 multiply() 捕获。之后即使 make_multiplier() 已经返回,double() 仍然可以使用 factor = 2。
make_multiplier(2)
factor
multiply()
make_multiplier()
double()
factor = 2
闭包保存的是变量的绑定关系,而不是把代码复制一份。不同的外层调用会产生不同的绑定关系,这也是工厂函数能够创建多个定制函数的原因。
内部函数可以读取外层变量,但如果要给这个变量重新赋值,需要使用 nonlocal。它表示「修改最近一层外层函数中的变量」:
nonlocal
01def make_counter(start=0): 02 count = start 03 04 def next_count(): 05 nonlocal count 06 count += 1 07 return count 08 09 return next_count 10 11counter = make_counter(10) 12print(counter()) # 11 13print(counter()) # 12 14print(counter()) # 13
如果没有 nonlocal,count += 1 会被当作在 next_count() 内创建局部变量。Python 会先读取这个尚未赋值的局部变量,于是抛出 UnboundLocalError。
count += 1
next_count()
UnboundLocalError
nonlocal 只能用于嵌套函数中的外层局部变量,不能用来修改模块级变量。修改全局变量需要 global,但在实际项目中通常更推荐把状态放进对象,或通过参数和返回值显式传递。
global
闭包常用于「函数工厂」:先配置一次规则,再得到一个可以重复使用的函数。例如,为不同角色创建权限检查器:
01def require_permission(required): 02 def check(user_permissions): 03 return required in user_permissions 04 05 return check 06 07can_edit = require_permission("edit") 08can_delete = require_permission("delete") 09 10print(can_edit({"read", "edit"})) # True 11print(can_delete({"read", "edit"})) # False
装饰器也是闭包的常见应用。装饰器通常返回一个内部函数,由它记住原函数,并在调用前后增加日志、鉴权或计时逻辑:
01from functools import wraps 02 03def log_call(function): 04 @wraps(function) 05 def wrapper(*args, **kwargs): 06 print(f"开始调用:{function.__name__}") 07 result = function(*args, **kwargs) 08 print("调用结束") 09 return result 10 11 return wrapper 12 13@log_call 14def add(left, right): 15 return left + right 16 17print(add(2, 3))
这里的 wrapper() 捕获了外层的 function。@log_call 语法会把 add 替换为 log_call(add) 返回的 wrapper,所以调用 add(2, 3) 时会先执行附加逻辑。
wrapper()
function
@log_call
add
log_call(add)
wrapper
add(2, 3)
在 FastAPI 或 LangChain 项目中,也可以用闭包生成带有固定配置的处理函数,例如为不同模型预先绑定模型名称,再把生成的函数交给路由或工具调用。闭包适合保存少量、相对稳定的配置;配置较多或状态复杂时,使用类通常更清晰。
闭包捕获的是变量,而不是创建闭包那一刻的值。循环中创建函数时,所有函数可能会引用同一个循环变量,这称为「晚绑定」:
1def make_functions(): 2 functions = [] 3 for number in range(3): 4 functions.append(lambda: number) 5 return functions 6 7functions = make_functions() 8print([function() for function in functions]) # [2, 2, 2]
这里的循环位于 make_functions() 内部,三个函数共享外层函数的 number。外层函数结束时它的值是 2,所以返回的三个闭包调用时都读取到 2。如果希望每次循环都保存当前值,可以使用默认参数在创建函数时绑定它:
make_functions()
number
2
1def make_functions(): 2 functions = [] 3 for number in range(3): 4 functions.append(lambda number=number: number) 5 return functions 6 7functions = make_functions() 8print([function() for function in functions]) # [0, 1, 2]
实际项目中,看到「循环里创建回调函数」时要特别注意这个问题。也可以把当前值传给另一个函数工厂,让每次调用都创建一个独立的闭包。
闭包还会延长被捕获对象的生命周期。如果闭包捕获了很大的列表、文件句柄或其他资源,长期保存这个闭包可能造成额外的内存或资源占用,因此需要及时释放不再使用的函数引用。
本篇把前面的知识放进一个可修改的 Python 项目。main.py 只负责接收参数并调用实验函数,closures_demo.py 保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。
main.py
closures_demo.py
01def make_greeting(language: str): 02 def greet(name: str) -> str: 03 return f"{language},{name}!" 04 return greet 05 06def make_multiplier(factor: int): 07 def multiply(number: int) -> int: 08 return number * factor 09 return multiply 10 11def make_counter(start: int = 0): 12 count = start 13 def next_count() -> int: 14 nonlocal count 15 count += 1 16 return count 17 return next_count 18 19def require_permission(required: str): 20 def check(user_permissions: set[str]) -> bool: 21 return required in user_permissions 22 return check 23 24def make_late_bound(): 25 functions = [] 26 for number in range(3): 27 functions.append(lambda: number) 28 return functions 29 30def make_bound_now(): 31 functions = [] 32 for number in range(3): 33 functions.append(lambda number=number: number) 34 return functions 35 36def build_report(factor: int, number: int, start: int) -> dict[str, object]: 37 multiply = make_multiplier(factor) 38 first_counter = make_counter(start) 39 second_counter = make_counter(start) 40 first_values = [first_counter() for _ in range(3)] 41 second_value = second_counter() 42 permissions = {"read", "edit"} 43 can_edit = require_permission("edit") 44 can_delete = require_permission("delete") 45 late_functions = make_late_bound() 46 bound_functions = make_bound_now() 47 print(f"第一个计数器:{first_values};第二个计数器:{second_value}") 48 return { 49 "greetings": { 50 "hello": make_greeting("你好")("小微"), 51 "morning": make_greeting("早上好")("小微"), 52 }, 53 "multiplier": {"factor": factor, "number": number, "result": multiply(number)}, 54 "independent_counters": { 55 "first": first_values, 56 "second": second_value, 57 "first_next": first_counter(), 58 }, 59 "permissions": { 60 "granted": sorted(permissions), 61 "can_edit": can_edit(permissions), 62 "can_delete": can_delete(permissions), 63 }, 64 "late_binding": [function() for function in late_functions], 65 "bound_now": [function() for function in bound_functions], 66 } 67
01from fastapi import FastAPI, Query 02 03from closures_demo import build_report 04 05app = FastAPI() 06 07@app.get("/closures") 08async def closures( 09 factor: int = Query(3, ge=-10, le=10), 10 number: int = Query(5, ge=-1000, le=1000), 11 start: int = Query(10, ge=0, le=1000), 12) -> dict[str, object]: 13 return build_report(factor, number, start) 14
01[project] 02name = "python-closures" 03version = "0.1.0" 04description = "Python 闭包" 05readme = "README.md" 06requires-python = ">=3.12" 07dependencies = [ 08 "fastapi[standard]==0.136.1; sys_platform != 'emscripten'", 09 "fastapi==0.136.1; sys_platform == 'emscripten'", 10 "pydantic==2.12.5", 11 "httpx==0.28.1", 12] 13 14[tool.uv] 15package = false 16
其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回 422。
422
打开在线案例,点击运行,等待环境就绪。案例预览默认使用 GET,地址是:
GET
1/closures?factor=3&number=5&start=10
默认参数得到乘法结果 15;第一个计数器依次返回 [11, 12, 13],另一个计数器第一次返回 11,再调用第一个计数器得到 14。这两个函数各自保存了 count,不会因为另一个计数器运行而增加。
15
[11, 12, 13]
11
14
count
late_binding 为 [2, 2, 2],bound_now 为 [0, 1, 2]。这里把循环放在工厂函数内部,lambda 引用的是外层函数的局部变量,因而确实形成闭包。默认参数版本把当前数字保存为参数默认值。
late_binding
[2, 2, 2]
bound_now
[0, 1, 2]
每次请求重新创建计数器和权限检查器;重复发送相同请求会得到相同结果。可以修改工厂函数的返回行为,再保存并运行,观察 nonlocal、自由变量和默认参数绑定的差异。
下载 ZIP 并解压,在项目目录执行:
1uv run fastapi dev main.py
然后打开 http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。
http://127.0.0.1:8000/docs
本机使用 .python-version 指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。
.python-version
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 认识
闭包(closure)不是一种新的数据类型,而是一种函数关系:一个函数定义在另一个函数内部,并且引用了外层函数的变量。即使外层函数已经执行结束,内部函数仍然可以使用那些变量。
可以把它理解成「函数和它需要的环境一起被保存下来」。下面的
make_greeting()执行后返回了内部函数greet(),返回的函数仍然记得当时传入的language:make_greeting()返回的不是问候语字符串,而是一个函数。每次调用make_greeting()都会创建一份独立的外层变量,因此say_hello和say_morning互不影响。2. 捕获
内部函数读取外层函数的变量时,就形成了闭包。这个变量也叫「自由变量」:它不是内部函数的参数,也不是内部函数里新定义的局部变量,但内部函数仍然能够访问它。
调用
make_multiplier(2)时,factor的值被multiply()捕获。之后即使make_multiplier()已经返回,double()仍然可以使用factor = 2。闭包保存的是变量的绑定关系,而不是把代码复制一份。不同的外层调用会产生不同的绑定关系,这也是工厂函数能够创建多个定制函数的原因。
3. 修改
内部函数可以读取外层变量,但如果要给这个变量重新赋值,需要使用
nonlocal。它表示「修改最近一层外层函数中的变量」:如果没有
nonlocal,count += 1会被当作在next_count()内创建局部变量。Python 会先读取这个尚未赋值的局部变量,于是抛出UnboundLocalError。nonlocal只能用于嵌套函数中的外层局部变量,不能用来修改模块级变量。修改全局变量需要global,但在实际项目中通常更推荐把状态放进对象,或通过参数和返回值显式传递。4. 用途
闭包常用于「函数工厂」:先配置一次规则,再得到一个可以重复使用的函数。例如,为不同角色创建权限检查器:
装饰器也是闭包的常见应用。装饰器通常返回一个内部函数,由它记住原函数,并在调用前后增加日志、鉴权或计时逻辑:
这里的
wrapper()捕获了外层的function。@log_call语法会把add替换为log_call(add)返回的wrapper,所以调用add(2, 3)时会先执行附加逻辑。在 FastAPI 或 LangChain 项目中,也可以用闭包生成带有固定配置的处理函数,例如为不同模型预先绑定模型名称,再把生成的函数交给路由或工具调用。闭包适合保存少量、相对稳定的配置;配置较多或状态复杂时,使用类通常更清晰。
5. 陷阱
闭包捕获的是变量,而不是创建闭包那一刻的值。循环中创建函数时,所有函数可能会引用同一个循环变量,这称为「晚绑定」:
这里的循环位于
make_functions()内部,三个函数共享外层函数的number。外层函数结束时它的值是2,所以返回的三个闭包调用时都读取到2。如果希望每次循环都保存当前值,可以使用默认参数在创建函数时绑定它:实际项目中,看到「循环里创建回调函数」时要特别注意这个问题。也可以把当前值传给另一个函数工厂,让每次调用都创建一个独立的闭包。
闭包还会延长被捕获对象的生命周期。如果闭包捕获了很大的列表、文件句柄或其他资源,长期保存这个闭包可能造成额外的内存或资源占用,因此需要及时释放不再使用的函数引用。
6. 在线闭包实验
本篇把前面的知识放进一个可修改的 Python 项目。
main.py只负责接收参数并调用实验函数,closures_demo.py保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。6.1 完整实验代码
6.2 接口与配置
其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回
422。6.3 运行和观察
打开在线案例,点击运行,等待环境就绪。案例预览默认使用
GET,地址是:默认参数得到乘法结果
15;第一个计数器依次返回[11, 12, 13],另一个计数器第一次返回11,再调用第一个计数器得到14。这两个函数各自保存了count,不会因为另一个计数器运行而增加。late_binding为[2, 2, 2],bound_now为[0, 1, 2]。这里把循环放在工厂函数内部,lambda 引用的是外层函数的局部变量,因而确实形成闭包。默认参数版本把当前数字保存为参数默认值。每次请求重新创建计数器和权限检查器;重复发送相同请求会得到相同结果。可以修改工厂函数的返回行为,再保存并运行,观察
nonlocal、自由变量和默认参数绑定的差异。6.4 本机运行
下载 ZIP 并解压,在项目目录执行:
然后打开
http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。本机使用
.python-version指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。