跳到主内容

LangChain Python

最后更新: 2026-10-11

1. 传入逻辑

普通函数通常接收数据,然后按照函数内部写好的步骤处理数据:

normal-function.py
1
def double(number):
2
return number * 2
3
4
print(double(3)) # 6

如果希望同一个函数可以处理不同规则,就可以把「逻辑片段」也作为参数传进去。下面的 apply_twice() 不关心具体要做什么,只负责把传入的动作执行两次:

pass-logic.py
1
def add_exclamation(text):
2
return text + "!"
3
4
def apply_twice(value, action):
5
return action(action(value))
6
7
print(apply_twice("你好", add_exclamation)) # 你好!!

这里的 action 不是一个普通数据,而是一个可以被调用的函数。apply_twice() 把执行时机和执行次数负责好,把具体逻辑交给调用方,这就是「把行为传给函数」的基本思路。

2. 函数对象

在 Python 中,函数也是对象,可以像字符串、数字一样被赋值、放进列表、作为参数传入,或者作为返回值交给其他代码:

function-value.py
1
def add(left, right):
2
return left + right
3
4
operation = add
5
operations = [add, lambda left, right: left - right]
6
7
print(operation(2, 3))
8
print(operations[0](5, 2)) # 7
9
print(operations[1](5, 2)) # 3

注意,add 和 add() 含义不同:

  • add 表示函数对象本身,可以传给另一个函数;
  • add() 表示立即调用函数,括号中的值是传入的实参。

当一个函数接收另一个函数作为参数,或者返回一个函数时,就可以称为高阶函数。高阶函数并不神秘,它只是利用了 Python「函数也是值」这一特性。

函数返回函数时,可以把一部分配置提前保存下来。这个模式也叫函数工厂:

function-factory.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(4)) # 8
11
print(triple(4)) # 12

make_multiplier() 返回了一个函数,同时这个函数记住了 factor。这正是上一节「闭包」中介绍的关系:高阶函数描述的是函数的传入或返回,闭包强调返回的函数还保存了外层变量。

3. 映射

map(function, iterable) 会把函数应用到可遍历对象的每个元素,并返回一个迭代器。需要查看全部结果时,通常使用 list() 转换:

map-basic.py
1
def to_upper(text):
2
return text.upper()
3
4
topics = ["python", "fastapi", "langchain"]
5
result = map(to_upper, topics)
6
7
print(list(result)) # ['PYTHON', 'FASTAPI', 'LANGCHAIN']

map() 不会直接修改原列表,也不会立刻把所有结果保存成新列表。迭代器被消费后就不能再次从头读取:

map-lazy.py
1
numbers = [1, 2, 3]
2
result = map(lambda number: number * 2, numbers)
3
4
print(list(result)) # [2, 4, 6]
5
print(list(result)) # []

如果转换逻辑很简单,列表推导式通常更直观:

map-comprehension.py
1
numbers = [1, 2, 3]
2
result = [number * 2 for number in numbers]
3
4
print(result) # [2, 4, 6]

map() 适合把一个已经命名的处理函数应用到整组数据;列表推导式适合在一行中表达简单转换。两者的重点都是「每个元素都得到一个对应结果」。

4. 筛选与汇总

filter(function, iterable) 会保留函数返回真值的元素。传入的函数通常叫谓词(predicate),它只负责回答「这个元素是否符合条件」:

filter-basic.py
1
def is_adult(age):
2
return age >= 18
3
4
ages = [12, 18, 20, 15, 30]
5
adults = filter(is_adult, ages)
6
7
print(list(adults)) # [18, 20, 30]

和 map() 一样,filter() 返回的是惰性迭代器。条件简单时,也可以使用列表推导式:

filter-comprehension.py
1
ages = [12, 18, 20, 15, 30]
2
adults = [age for age in ages if age >= 18]
3
4
print(adults) # [18, 20, 30]

reduce() 用来把一组元素逐步合并成一个结果。它位于 functools 模块中,传入的函数每次接收「当前累计值」和「下一个元素」:

reduce-sum.py
1
from functools import reduce
2
3
def add(total, number):
4
return total + number
5
6
numbers = [1, 2, 3, 4]
7
total = reduce(add, numbers, 0)
8
9
print(total) # 10

上面的计算过程可以理解为 (((0 + 1) + 2) + 3) + 4。第三个参数 0 是初始累计值,它还能让空列表有明确的结果:

reduce-product.py
1
from functools import reduce
2
3
numbers = [2, 3, 4]
4
product = reduce(lambda total, number: total * number, numbers, 1)
5
6
print(product) # 24

reduce() 很灵活,但不一定是最易读的选择。求和优先使用 sum(),求最大值或最小值优先使用 max()、min();只有在确实需要按顺序累积自定义结果时,才使用 reduce()。

5. 排序

sorted(iterable, key=None, reverse=False) 会返回一个新的列表,不会修改原来的可遍历对象。key 接收一个函数,用来告诉 Python 比较每个元素的哪个值:

sorted-basic.py
1
scores = [80, 95, 68, 90]
2
3
print(sorted(scores)) # [68, 80, 90, 95]
4
print(sorted(scores, reverse=True)) # [95, 90, 80, 68]

如果元素是字典或对象,可以使用 key 提取排序依据:

sorted-key.py
1
students = [
2
{"name": "小明", "score": 88},
3
{"name": "小红", "score": 95},
4
{"name": "小刚", "score": 82},
5
]
6
7
ordered = sorted(students, key=lambda student: student["score"], reverse=True)
8
print(ordered)

sorted() 和列表的 sort() 不同:sorted() 返回新列表,可以处理任何可遍历对象;sort() 是列表的方法,会直接修改原列表,并返回 None:

sort-in-place.py
1
numbers = [3, 1, 2]
2
result = numbers.sort()
3
4
print(numbers) # [1, 2, 3]
5
print(result) # None

key 函数只负责为每个元素提供比较值,不需要自己实现排序算法。Python 的排序是稳定的:当两个元素的 key 相同时,它们会保留原来的相对顺序。

6. 组合

map()、filter() 和 sorted() 可以组合起来,把数据处理过程写成清晰的步骤。下面先筛选成年人,再按年龄从大到小排序:

pipeline.py
01
users = [
02
{"name": "小明", "age": 17},
03
{"name": "小红", "age": 23},
04
{"name": "小刚", "age": 20},
05
]
06
07
adults = filter(lambda user: user["age"] >= 18, users)
08
ordered = sorted(adults, key=lambda user: user["age"], reverse=True)
09
10
print(list(ordered))

当步骤较多时,可以先把每一步命名为普通函数,再传给高阶函数。命名函数更容易调试和复用:

named-pipeline.py
01
users = [
02
{"name": "小明", "age": 17},
03
{"name": "小红", "age": 23},
04
{"name": "小刚", "age": 20},
05
]
06
07
def is_adult(user):
08
return user["age"] >= 18
09
10
def age_key(user):
11
return user["age"]
12
13
adults = filter(is_adult, users)
14
ordered = sorted(adults, key=age_key, reverse=True)

lambda 适合很短的单表达式逻辑,例如 lambda user: user["age"]。如果逻辑需要分支、异常处理或多行说明,就应该写成普通函数。高阶函数的目标是把「处理流程」和「具体规则」分开,而不是为了少写几行代码而强行嵌套表达式。

在 FastAPI 和 LangChain 项目中,这种思想会出现在请求校验、消息转换、工具回调和链式处理里:框架负责调用流程,开发者把某个步骤的具体行为以函数形式传进去。

7. 在线高阶函数实验

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

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

7.1 完整实验代码

higher_order_demo.py
01
from functools import reduce
02
03
def to_upper(text: str) -> str:
04
return text.upper()
05
06
def age_at_least(minimum_age: int):
07
def matches(user: dict[str, object]) -> bool:
08
return user["age"] >= minimum_age
09
return matches
10
11
def score_key(user: dict[str, object]) -> int:
12
return user["score"]
13
14
def add_score(total: int, user: dict[str, object]) -> int:
15
return total + user["score"]
16
17
def apply_twice(value: str, action) -> str:
18
return action(action(value))
19
20
def add_exclamation(text: str) -> str:
21
return text + "!"
22
23
def build_report(topics: list[str], users: list[dict[str, object]], minimum_age: int) -> dict[str, object]:
24
mapped = map(to_upper, topics)
25
first_read = list(mapped)
26
second_read = list(mapped)
27
selected = list(filter(age_at_least(minimum_age), users))
28
ordered = sorted(selected, key=score_key, reverse=True)
29
score_total = reduce(add_score, selected, 0)
30
in_place_scores = [user["score"] for user in users]
31
sort_result = in_place_scores.sort()
32
print(f"筛选后保留 {len(selected)} 人,分数总和为 {score_total}")
33
return {
34
"map": {"original": topics, "first_read": first_read, "second_read": second_read},
35
"filter": {"minimum_age": minimum_age, "selected": selected},
36
"sorted": {"original": users, "ordered": ordered},
37
"reduce": {"total_score": score_total, "count": len(selected)},
38
"sort_in_place": {"sorted_scores": in_place_scores, "return_value": sort_result},
39
"callback": apply_twice(topics[0], add_exclamation) if topics else None,
40
}
41

7.2 接口与配置

main.py
01
from typing import Annotated
02
03
from fastapi import FastAPI
04
from pydantic import BaseModel, Field
05
06
from higher_order_demo import build_report
07
08
app = FastAPI()
09
Topic = Annotated[str, Field(max_length=80)]
10
11
class UserRecord(BaseModel):
12
name: str = Field(min_length=1, max_length=80)
13
age: int = Field(ge=0, le=120)
14
score: int = Field(ge=0, le=100)
15
16
class PipelineRequest(BaseModel):
17
topics: list[Topic] = Field(max_length=30)
18
users: list[UserRecord] = Field(max_length=50)
19
minimum_age: int = Field(default=18, ge=0, le=120)
20
21
@app.post("/higher-order")
22
async def higher_order(request: PipelineRequest) -> dict[str, object]:
23
users = [user.model_dump() for user in request.users]
24
return build_report(request.topics, users, request.minimum_age)
25
pyproject.toml
01
[project]
02
name = "python-higher-order-functions"
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。

7.3 运行和观察

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

code.ts
1
/higher-order

请求体可以直接编辑:

code.ts
01
{
02
"topics": [
03
"python",
04
"fastapi",
05
"langchain"
06
],
07
"users": [
08
{
09
"name": "小明",
10
"age": 17,
11
"score": 95
12
},
13
{
14
"name": "小红",
15
"age": 23,
16
"score": 88
17
},
18
{
19
"name": "小刚",
20
"age": 20,
21
"score": 88
22
}
23
],
24
"minimum_age": 18
25
}

默认请求中的英文主题会转换成 PYTHON、FASTAPI、LANGCHAIN。同一个 map 迭代器第二次读取返回空数组,说明迭代器已经被消费。筛选后保留小红、小刚,分数总和为 176;两人的分数相同,稳定排序保留了原来的相对顺序。

可以修改请求体中的年龄、分数或 minimum_age 后直接发送请求,观察筛选与排序结果。将 topics、users 设为空数组时,转换和排序结果为空,累计分数为 0,回调示例为 null。list.sort() 返回的 None 在响应中显示为 null。

可以把 score_key() 改为按年龄取值,或修改 to_upper() 的转换规则,保存并重新运行。请求数量和每条记录的范围由 Pydantic 校验,错误输入会返回 422,不需要把筛选逻辑写进接口函数。

7.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 查看公开讨论。

添加评论
    即时渲染