普通函数通常接收数据,然后按照函数内部写好的步骤处理数据:
1def double(number): 2 return number * 2 3 4print(double(3)) # 6
如果希望同一个函数可以处理不同规则,就可以把「逻辑片段」也作为参数传进去。下面的 apply_twice() 不关心具体要做什么,只负责把传入的动作执行两次:
apply_twice()
1def add_exclamation(text): 2 return text + "!" 3 4def apply_twice(value, action): 5 return action(action(value)) 6 7print(apply_twice("你好", add_exclamation)) # 你好!!
这里的 action 不是一个普通数据,而是一个可以被调用的函数。apply_twice() 把执行时机和执行次数负责好,把具体逻辑交给调用方,这就是「把行为传给函数」的基本思路。
action
在 Python 中,函数也是对象,可以像字符串、数字一样被赋值、放进列表、作为参数传入,或者作为返回值交给其他代码:
1def add(left, right): 2 return left + right 3 4operation = add 5operations = [add, lambda left, right: left - right] 6 7print(operation(2, 3)) 8print(operations[0](5, 2)) # 7 9print(operations[1](5, 2)) # 3
注意,add 和 add() 含义不同:
add
add()
当一个函数接收另一个函数作为参数,或者返回一个函数时,就可以称为高阶函数。高阶函数并不神秘,它只是利用了 Python「函数也是值」这一特性。
函数返回函数时,可以把一部分配置提前保存下来。这个模式也叫函数工厂:
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(4)) # 8 11print(triple(4)) # 12
make_multiplier() 返回了一个函数,同时这个函数记住了 factor。这正是上一节「闭包」中介绍的关系:高阶函数描述的是函数的传入或返回,闭包强调返回的函数还保存了外层变量。
make_multiplier()
factor
map(function, iterable) 会把函数应用到可遍历对象的每个元素,并返回一个迭代器。需要查看全部结果时,通常使用 list() 转换:
map(function, iterable)
list()
1def to_upper(text): 2 return text.upper() 3 4topics = ["python", "fastapi", "langchain"] 5result = map(to_upper, topics) 6 7print(list(result)) # ['PYTHON', 'FASTAPI', 'LANGCHAIN']
map() 不会直接修改原列表,也不会立刻把所有结果保存成新列表。迭代器被消费后就不能再次从头读取:
map()
1numbers = [1, 2, 3] 2result = map(lambda number: number * 2, numbers) 3 4print(list(result)) # [2, 4, 6] 5print(list(result)) # []
如果转换逻辑很简单,列表推导式通常更直观:
1numbers = [1, 2, 3] 2result = [number * 2 for number in numbers] 3 4print(result) # [2, 4, 6]
map() 适合把一个已经命名的处理函数应用到整组数据;列表推导式适合在一行中表达简单转换。两者的重点都是「每个元素都得到一个对应结果」。
filter(function, iterable) 会保留函数返回真值的元素。传入的函数通常叫谓词(predicate),它只负责回答「这个元素是否符合条件」:
filter(function, iterable)
1def is_adult(age): 2 return age >= 18 3 4ages = [12, 18, 20, 15, 30] 5adults = filter(is_adult, ages) 6 7print(list(adults)) # [18, 20, 30]
和 map() 一样,filter() 返回的是惰性迭代器。条件简单时,也可以使用列表推导式:
filter()
1ages = [12, 18, 20, 15, 30] 2adults = [age for age in ages if age >= 18] 3 4print(adults) # [18, 20, 30]
reduce() 用来把一组元素逐步合并成一个结果。它位于 functools 模块中,传入的函数每次接收「当前累计值」和「下一个元素」:
reduce()
functools
1from functools import reduce 2 3def add(total, number): 4 return total + number 5 6numbers = [1, 2, 3, 4] 7total = reduce(add, numbers, 0) 8 9print(total) # 10
上面的计算过程可以理解为 (((0 + 1) + 2) + 3) + 4。第三个参数 0 是初始累计值,它还能让空列表有明确的结果:
(((0 + 1) + 2) + 3) + 4
0
1from functools import reduce 2 3numbers = [2, 3, 4] 4product = reduce(lambda total, number: total * number, numbers, 1) 5 6print(product) # 24
reduce() 很灵活,但不一定是最易读的选择。求和优先使用 sum(),求最大值或最小值优先使用 max()、min();只有在确实需要按顺序累积自定义结果时,才使用 reduce()。
sum()
max()
min()
sorted(iterable, key=None, reverse=False) 会返回一个新的列表,不会修改原来的可遍历对象。key 接收一个函数,用来告诉 Python 比较每个元素的哪个值:
sorted(iterable, key=None, reverse=False)
key
1scores = [80, 95, 68, 90] 2 3print(sorted(scores)) # [68, 80, 90, 95] 4print(sorted(scores, reverse=True)) # [95, 90, 80, 68]
如果元素是字典或对象,可以使用 key 提取排序依据:
1students = [ 2 {"name": "小明", "score": 88}, 3 {"name": "小红", "score": 95}, 4 {"name": "小刚", "score": 82}, 5] 6 7ordered = sorted(students, key=lambda student: student["score"], reverse=True) 8print(ordered)
sorted() 和列表的 sort() 不同:sorted() 返回新列表,可以处理任何可遍历对象;sort() 是列表的方法,会直接修改原列表,并返回 None:
sorted()
sort()
None
1numbers = [3, 1, 2] 2result = numbers.sort() 3 4print(numbers) # [1, 2, 3] 5print(result) # None
key 函数只负责为每个元素提供比较值,不需要自己实现排序算法。Python 的排序是稳定的:当两个元素的 key 相同时,它们会保留原来的相对顺序。
map()、filter() 和 sorted() 可以组合起来,把数据处理过程写成清晰的步骤。下面先筛选成年人,再按年龄从大到小排序:
01users = [ 02 {"name": "小明", "age": 17}, 03 {"name": "小红", "age": 23}, 04 {"name": "小刚", "age": 20}, 05] 06 07adults = filter(lambda user: user["age"] >= 18, users) 08ordered = sorted(adults, key=lambda user: user["age"], reverse=True) 09 10print(list(ordered))
当步骤较多时,可以先把每一步命名为普通函数,再传给高阶函数。命名函数更容易调试和复用:
01users = [ 02 {"name": "小明", "age": 17}, 03 {"name": "小红", "age": 23}, 04 {"name": "小刚", "age": 20}, 05] 06 07def is_adult(user): 08 return user["age"] >= 18 09 10def age_key(user): 11 return user["age"] 12 13adults = filter(is_adult, users) 14ordered = sorted(adults, key=age_key, reverse=True)
lambda 适合很短的单表达式逻辑,例如 lambda user: user["age"]。如果逻辑需要分支、异常处理或多行说明,就应该写成普通函数。高阶函数的目标是把「处理流程」和「具体规则」分开,而不是为了少写几行代码而强行嵌套表达式。
lambda
lambda user: user["age"]
在 FastAPI 和 LangChain 项目中,这种思想会出现在请求校验、消息转换、工具回调和链式处理里:框架负责调用流程,开发者把某个步骤的具体行为以函数形式传进去。
本篇把前面的知识放进一个可修改的 Python 项目。main.py 只负责接收参数并调用实验函数,higher_order_demo.py 保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。
main.py
higher_order_demo.py
01from functools import reduce 02 03def to_upper(text: str) -> str: 04 return text.upper() 05 06def age_at_least(minimum_age: int): 07 def matches(user: dict[str, object]) -> bool: 08 return user["age"] >= minimum_age 09 return matches 10 11def score_key(user: dict[str, object]) -> int: 12 return user["score"] 13 14def add_score(total: int, user: dict[str, object]) -> int: 15 return total + user["score"] 16 17def apply_twice(value: str, action) -> str: 18 return action(action(value)) 19 20def add_exclamation(text: str) -> str: 21 return text + "!" 22 23def 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
01from typing import Annotated 02 03from fastapi import FastAPI 04from pydantic import BaseModel, Field 05 06from higher_order_demo import build_report 07 08app = FastAPI() 09Topic = Annotated[str, Field(max_length=80)] 10 11class 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 16class 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") 22async 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
01[project] 02name = "python-higher-order-functions" 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
打开在线案例,点击运行,等待环境就绪。案例预览默认使用 POST,地址是:
POST
1/higher-order
请求体可以直接编辑:
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;两人的分数相同,稳定排序保留了原来的相对顺序。
PYTHON
FASTAPI
LANGCHAIN
map
176
可以修改请求体中的年龄、分数或 minimum_age 后直接发送请求,观察筛选与排序结果。将 topics、users 设为空数组时,转换和排序结果为空,累计分数为 0,回调示例为 null。list.sort() 返回的 None 在响应中显示为 null。
minimum_age
topics
users
null
list.sort()
可以把 score_key() 改为按年龄取值,或修改 to_upper() 的转换规则,保存并重新运行。请求数量和每条记录的范围由 Pydantic 校验,错误输入会返回 422,不需要把筛选逻辑写进接口函数。
score_key()
to_upper()
下载 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. 传入逻辑
普通函数通常接收数据,然后按照函数内部写好的步骤处理数据:
如果希望同一个函数可以处理不同规则,就可以把「逻辑片段」也作为参数传进去。下面的
apply_twice()不关心具体要做什么,只负责把传入的动作执行两次:这里的
action不是一个普通数据,而是一个可以被调用的函数。apply_twice()把执行时机和执行次数负责好,把具体逻辑交给调用方,这就是「把行为传给函数」的基本思路。2. 函数对象
在 Python 中,函数也是对象,可以像字符串、数字一样被赋值、放进列表、作为参数传入,或者作为返回值交给其他代码:
注意,
add和add()含义不同:add表示函数对象本身,可以传给另一个函数;add()表示立即调用函数,括号中的值是传入的实参。当一个函数接收另一个函数作为参数,或者返回一个函数时,就可以称为高阶函数。高阶函数并不神秘,它只是利用了 Python「函数也是值」这一特性。
函数返回函数时,可以把一部分配置提前保存下来。这个模式也叫函数工厂:
make_multiplier()返回了一个函数,同时这个函数记住了factor。这正是上一节「闭包」中介绍的关系:高阶函数描述的是函数的传入或返回,闭包强调返回的函数还保存了外层变量。3. 映射
map(function, iterable)会把函数应用到可遍历对象的每个元素,并返回一个迭代器。需要查看全部结果时,通常使用list()转换:map()不会直接修改原列表,也不会立刻把所有结果保存成新列表。迭代器被消费后就不能再次从头读取:如果转换逻辑很简单,列表推导式通常更直观:
map()适合把一个已经命名的处理函数应用到整组数据;列表推导式适合在一行中表达简单转换。两者的重点都是「每个元素都得到一个对应结果」。4. 筛选与汇总
filter(function, iterable)会保留函数返回真值的元素。传入的函数通常叫谓词(predicate),它只负责回答「这个元素是否符合条件」:和
map()一样,filter()返回的是惰性迭代器。条件简单时,也可以使用列表推导式:reduce()用来把一组元素逐步合并成一个结果。它位于functools模块中,传入的函数每次接收「当前累计值」和「下一个元素」:上面的计算过程可以理解为
(((0 + 1) + 2) + 3) + 4。第三个参数0是初始累计值,它还能让空列表有明确的结果:reduce()很灵活,但不一定是最易读的选择。求和优先使用sum(),求最大值或最小值优先使用max()、min();只有在确实需要按顺序累积自定义结果时,才使用reduce()。5. 排序
sorted(iterable, key=None, reverse=False)会返回一个新的列表,不会修改原来的可遍历对象。key接收一个函数,用来告诉 Python 比较每个元素的哪个值:如果元素是字典或对象,可以使用
key提取排序依据:sorted()和列表的sort()不同:sorted()返回新列表,可以处理任何可遍历对象;sort()是列表的方法,会直接修改原列表,并返回None:key函数只负责为每个元素提供比较值,不需要自己实现排序算法。Python 的排序是稳定的:当两个元素的key相同时,它们会保留原来的相对顺序。6. 组合
map()、filter()和sorted()可以组合起来,把数据处理过程写成清晰的步骤。下面先筛选成年人,再按年龄从大到小排序:当步骤较多时,可以先把每一步命名为普通函数,再传给高阶函数。命名函数更容易调试和复用:
lambda适合很短的单表达式逻辑,例如lambda user: user["age"]。如果逻辑需要分支、异常处理或多行说明,就应该写成普通函数。高阶函数的目标是把「处理流程」和「具体规则」分开,而不是为了少写几行代码而强行嵌套表达式。在 FastAPI 和 LangChain 项目中,这种思想会出现在请求校验、消息转换、工具回调和链式处理里:框架负责调用流程,开发者把某个步骤的具体行为以函数形式传进去。
7. 在线高阶函数实验
本篇把前面的知识放进一个可修改的 Python 项目。
main.py只负责接收参数并调用实验函数,higher_order_demo.py保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。7.1 完整实验代码
7.2 接口与配置
其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回
422。7.3 运行和观察
打开在线案例,点击运行,等待环境就绪。案例预览默认使用
POST,地址是:请求体可以直接编辑:
默认请求中的英文主题会转换成
PYTHON、FASTAPI、LANGCHAIN。同一个map迭代器第二次读取返回空数组,说明迭代器已经被消费。筛选后保留小红、小刚,分数总和为176;两人的分数相同,稳定排序保留了原来的相对顺序。可以修改请求体中的年龄、分数或
minimum_age后直接发送请求,观察筛选与排序结果。将topics、users设为空数组时,转换和排序结果为空,累计分数为0,回调示例为null。list.sort()返回的None在响应中显示为null。可以把
score_key()改为按年龄取值,或修改to_upper()的转换规则,保存并重新运行。请求数量和每条记录的范围由 Pydantic 校验,错误输入会返回422,不需要把筛选逻辑写进接口函数。7.4 本机运行
下载 ZIP 并解压,在项目目录执行:
然后打开
http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。本机使用
.python-version指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。