跳到主内容

LangChain Python

最后更新: 2026-10-11

1. 认识

闭包(closure)不是一种新的数据类型,而是一种函数关系:一个函数定义在另一个函数内部,并且引用了外层函数的变量。即使外层函数已经执行结束,内部函数仍然可以使用那些变量。

可以把它理解成「函数和它需要的环境一起被保存下来」。下面的 make_greeting() 执行后返回了内部函数 greet(),返回的函数仍然记得当时传入的 language:

greeting.py
01
def make_greeting(language):
02
def greet(name):
03
return f"{language},{name}!"
04
05
return greet
06
07
say_hello = make_greeting("你好")
08
say_morning = make_greeting("早上好")
09
10
print(say_hello("小明")) # 你好,小明!
11
print(say_morning("小红")) # 早上好,小红!

make_greeting() 返回的不是问候语字符串,而是一个函数。每次调用 make_greeting() 都会创建一份独立的外层变量,因此 say_hello 和 say_morning 互不影响。

2. 捕获

内部函数读取外层函数的变量时,就形成了闭包。这个变量也叫「自由变量」:它不是内部函数的参数,也不是内部函数里新定义的局部变量,但内部函数仍然能够访问它。

capture.py
01
def make_multiplier(factor):
02
def multiply(number):
03
return number * factor
04
05
return multiply
06
07
double = make_multiplier(2)
08
triple = make_multiplier(3)
09
10
print(double(5)) # 10
11
print(triple(5)) # 15

调用 make_multiplier(2) 时,factor 的值被 multiply() 捕获。之后即使 make_multiplier() 已经返回,double() 仍然可以使用 factor = 2。

闭包保存的是变量的绑定关系,而不是把代码复制一份。不同的外层调用会产生不同的绑定关系,这也是工厂函数能够创建多个定制函数的原因。

3. 修改

内部函数可以读取外层变量,但如果要给这个变量重新赋值,需要使用 nonlocal。它表示「修改最近一层外层函数中的变量」:

counter.py
01
def 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
11
counter = make_counter(10)
12
print(counter()) # 11
13
print(counter()) # 12
14
print(counter()) # 13

如果没有 nonlocal,count += 1 会被当作在 next_count() 内创建局部变量。Python 会先读取这个尚未赋值的局部变量,于是抛出 UnboundLocalError。

nonlocal 只能用于嵌套函数中的外层局部变量,不能用来修改模块级变量。修改全局变量需要 global,但在实际项目中通常更推荐把状态放进对象,或通过参数和返回值显式传递。

4. 用途

闭包常用于「函数工厂」:先配置一次规则,再得到一个可以重复使用的函数。例如,为不同角色创建权限检查器:

permission.py
01
def require_permission(required):
02
def check(user_permissions):
03
return required in user_permissions
04
05
return check
06
07
can_edit = require_permission("edit")
08
can_delete = require_permission("delete")
09
10
print(can_edit({"read", "edit"})) # True
11
print(can_delete({"read", "edit"})) # False

装饰器也是闭包的常见应用。装饰器通常返回一个内部函数,由它记住原函数,并在调用前后增加日志、鉴权或计时逻辑:

decorator.py
01
from functools import wraps
02
03
def 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
14
def add(left, right):
15
return left + right
16
17
print(add(2, 3))

这里的 wrapper() 捕获了外层的 function。@log_call 语法会把 add 替换为 log_call(add) 返回的 wrapper,所以调用 add(2, 3) 时会先执行附加逻辑。

在 FastAPI 或 LangChain 项目中,也可以用闭包生成带有固定配置的处理函数,例如为不同模型预先绑定模型名称,再把生成的函数交给路由或工具调用。闭包适合保存少量、相对稳定的配置;配置较多或状态复杂时,使用类通常更清晰。

5. 陷阱

闭包捕获的是变量,而不是创建闭包那一刻的值。循环中创建函数时,所有函数可能会引用同一个循环变量,这称为「晚绑定」:

late-binding.py
1
def make_functions():
2
functions = []
3
for number in range(3):
4
functions.append(lambda: number)
5
return functions
6
7
functions = make_functions()
8
print([function() for function in functions]) # [2, 2, 2]

这里的循环位于 make_functions() 内部,三个函数共享外层函数的 number。外层函数结束时它的值是 2,所以返回的三个闭包调用时都读取到 2。如果希望每次循环都保存当前值,可以使用默认参数在创建函数时绑定它:

bind-now.py
1
def make_functions():
2
functions = []
3
for number in range(3):
4
functions.append(lambda number=number: number)
5
return functions
6
7
functions = make_functions()
8
print([function() for function in functions]) # [0, 1, 2]

实际项目中,看到「循环里创建回调函数」时要特别注意这个问题。也可以把当前值传给另一个函数工厂,让每次调用都创建一个独立的闭包。

闭包还会延长被捕获对象的生命周期。如果闭包捕获了很大的列表、文件句柄或其他资源,长期保存这个闭包可能造成额外的内存或资源占用,因此需要及时释放不再使用的函数引用。

6. 在线闭包实验

本篇把前面的知识放进一个可修改的 Python 项目。main.py 只负责接收参数并调用实验函数,closures_demo.py 保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。

目录结构
使用上下方向键浏览目录,左右方向键展开或收起,Enter 或空格切换展开状态。
    • main.pyFastAPI 接口入口
    • closures_demo.py本篇 Python 实验
    • pyproject.toml项目配置与基础依赖
    • .python-version本机 Python 3.12
    • .gitignore排除环境和缓存文件
    • README.md运行方法与实验说明

6.1 完整实验代码

closures_demo.py
01
def make_greeting(language: str):
02
def greet(name: str) -> str:
03
return f"{language},{name}!"
04
return greet
05
06
def make_multiplier(factor: int):
07
def multiply(number: int) -> int:
08
return number * factor
09
return multiply
10
11
def 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
19
def require_permission(required: str):
20
def check(user_permissions: set[str]) -> bool:
21
return required in user_permissions
22
return check
23
24
def make_late_bound():
25
functions = []
26
for number in range(3):
27
functions.append(lambda: number)
28
return functions
29
30
def make_bound_now():
31
functions = []
32
for number in range(3):
33
functions.append(lambda number=number: number)
34
return functions
35
36
def 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

6.2 接口与配置

main.py
01
from fastapi import FastAPI, Query
02
03
from closures_demo import build_report
04
05
app = FastAPI()
06
07
@app.get("/closures")
08
async 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
pyproject.toml
01
[project]
02
name = "python-closures"
03
version = "0.1.0"
04
description = "Python 闭包"
05
readme = "README.md"
06
requires-python = ">=3.12"
07
dependencies = [
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]
15
package = false
16

其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回 422。

6.3 运行和观察

打开在线案例,点击运行,等待环境就绪。案例预览默认使用 GET,地址是:

code.ts
1
/closures?factor=3&number=5&start=10

默认参数得到乘法结果 15;第一个计数器依次返回 [11, 12, 13],另一个计数器第一次返回 11,再调用第一个计数器得到 14。这两个函数各自保存了 count,不会因为另一个计数器运行而增加。

late_binding 为 [2, 2, 2],bound_now 为 [0, 1, 2]。这里把循环放在工厂函数内部,lambda 引用的是外层函数的局部变量,因而确实形成闭包。默认参数版本把当前数字保存为参数默认值。

每次请求重新创建计数器和权限检查器;重复发送相同请求会得到相同结果。可以修改工厂函数的返回行为,再保存并运行,观察 nonlocal、自由变量和默认参数绑定的差异。

6.4 本机运行

下载 ZIP 并解压,在项目目录执行:

code.ts
1
uv run fastapi dev main.py

然后打开 http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。

本机使用 .python-version 指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。

正在验证登录状态
请稍候,验证完成后将继续显示文章内容

此段落已有评论,按 Enter 查看评论及回复列表。

评论-

文章反应
评论与回复

连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。

添加评论
    即时渲染