技术文档

Appearance

Python 偏函数：给函数的参数"预设默认值" ​

引言：奶茶店的"固定搭配" ​

你去奶茶店点单，店员问：甜度？冰度？加料？尺寸？……一杯奶茶要回答四五个问题。

常喝的人都有一套自己的"固定搭配"："老样子，三分糖、少冰、加珍珠。"——你只用说"老样子"，店员就知道剩下的参数是什么。

Python 中的函数也一样：有些函数参数很多，但在你的项目里，某几个参数的值几乎不变，每次调用都重复写一遍，又烦又容易错。

偏函数（Partial Function）解决的就是这个问题：把函数的部分参数预先固定住，生成一个"更好用的新函数"。

注意：Python 的"偏函数"和数学里的偏函数不是一回事，名字撞车纯属巧合。你只需要记住：它是 functools 模块提供的一个"参数预设工具"。

一、从一个实际问题出发：进制的烦恼 ​

1.1 int() 的隐藏技能 ​

我们都知道 int() 可以把字符串转成整数：

python
>>> int('12345')
12345

但 int() 其实还有一个参数 base，可以按 N 进制转换，默认值是 10（十进制）：

python
>>> int('12345', base=8)    # 按八进制解读
5349

>>> int('12345', base=16)   # 按十六进制解读
74565

1.2 重复写参数的烦恼 ​

假设你在做一个嵌入式项目，要处理大量二进制字符串，每次都得写 base=2：

python
int('1000000', base=2)
int('1010101', base=2)
int('1111111', base=2)
# ...写了几十上百次 base=2

烦不烦？而且哪天手滑写成 base=3，bug 就找上你了。

1.3 传统解法：自己包一层函数 ​

python
def int2(x, base=2):
    return int(x, base)

>>> int2('1000000')
64
>>> int2('1010101')
85

问题解决了。但每次遇到这种需求都要手写一个"包装函数"，有点麻烦。有没有更省事的办法？

二、偏函数登场：functools.partial ​

2.1 一行代码替代手写包装 ​

python
>>> import functools
>>> int2 = functools.partial(int, base=2)

>>> int2('1000000')
64
>>> int2('1010101')
85

效果和手写的 def int2(...) 完全一样，但只需要一行代码。

2.2 偏函数做了什么？ ​

functools.partial 的作用一句话概括：

把一个函数的某些参数固定住，返回一个新函数。调用新函数时，固定的参数不用再写。

原函数：int(x, base=10)
              │
              ▼ functools.partial(int, base=2)
              │
新函数：int2(x)        ← base 被"焊死"为 2

生活化理解：就像给奶茶店留了一张"点单模板卡"——甜度、冰度、加料都提前填好，以后只要报"奶茶 + 模板卡"，不用重复回答所有问题。

2.3 固定的参数还能"临时反悔" ​

偏函数只是给参数设了新的默认值，并不是锁死。调用时依然可以传入其他值覆盖它：

python
>>> int2('1000000', base=10)   # 临时改用十进制
1000000

生活化理解：模板卡上写着"三分糖"，但今天你想喝甜一点，跟店员说"今天五分糖"，完全可以——模板只是默认值，不是强制规定。

三、偏函数的工作原理 ​

3.1 固定关键字参数 ​

functools.partial 实际上接收三类东西：**函数对象、*args、**kw**。

当写：

python
int2 = functools.partial(int, base=2)

它把 base=2 存起来。之后调用：

python
int2('10010')

等价于：

python
kw = {'base': 2}
int('10010', **kw)

很好理解：预先存好的关键字参数，调用时自动带上。

3.2 固定位置参数（重点！容易踩坑） ​

如果传入的是位置参数，它会被固定到参数列表的最左边：

python
>>> max2 = functools.partial(max, 10)

>>> max2(5, 6, 7)
10

为什么结果是 10？因为 max2(5, 6, 7) 实际执行的是：

python
args = (10, 5, 6, 7)   # 10 被加到了最前面！
max(*args)

生活化理解：位置参数像排队——你预先固定的那个人（10）永远站在队伍最前面，后面来的人都排在他后面。

这就是为什么偏函数固定位置参数要特别小心：你固定的不是"某个参数"，而是"第一个参数"。如果想固定中间的参数，必须用关键字形式：

python
# 想固定 print 的结束符 sep？位置参数做不到精准，用关键字
print_csv = functools.partial(print, sep=', ')

print_csv('苹果', '香蕉', '橙子')
# 苹果, 香蕉, 橙子

四、偏函数的经典应用场景 ​

4.1 场景一：固定"配置型"参数 ​

项目里所有的 HTTP 请求都发往同一台服务器，超时时间也一样：

python
import requests
import functools

# 固定 base_url 和 timeout
api_get = functools.partial(requests.get, timeout=5)

api_get('https://api.example.com/users')
api_get('https://api.example.com/orders')
# 不用每次都写 timeout=5

4.2 场景二：打造"专用工具函数" ​

python
# 专门打开 UTF-8 编码文件的 open
open_utf8 = functools.partial(open, encoding='utf-8')

with open_utf8('日记.txt') as f:
    content = f.read()

# 专门创建"忽略大小写排序"的 sorted
sorted_ci = functools.partial(sorted, key=str.lower)

sorted_ci(['Banana', 'apple', 'Cherry'])
# ['apple', 'Banana', 'Cherry']

每个新函数都是原函数的"定制款"，代码语义更清晰。

4.3 场景三：配合 GUI 回调传参 ​

tkinter 按钮的 command 只接受无参函数，但我们想给回调传参数，偏函数正好解决：

python
import tkinter as tk
import functools

def set_color(color):
    print(f"背景切换为：{color}")

root = tk.Tk()

# command 不接受参数，用 partial 把参数预先绑定
btn1 = tk.Button(root, text="红色", command=functools.partial(set_color, "红"))
btn2 = tk.Button(root, text="蓝色", command=functools.partial(set_color, "蓝"))
btn1.pack()
btn2.pack()
root.mainloop()

上一篇我们学过 lambda 也能干这事（command=lambda: set_color("红")），偏函数是另一种等价选择，当要绑定的参数较多时，partial 写起来更清爽。

4.4 场景四：配合 map() 等多参数函数 ​

map(func, iterable) 里的 func 只能接收一个参数。如果 func 需要额外参数，用偏函数先"喂"给它：

python
import functools

def power(base, exp):
    return base ** exp

# 固定 exp=2，得到"平方函数"，它只剩一个参数，可以进 map
square = functools.partial(power, exp=2)

list(map(square, [1, 2, 3, 4, 5]))
# [1, 4, 9, 16, 25]

4.5 场景五：给日志函数预设级别 ​

python
import logging
import functools

def log(level, message):
    print(f"[{level}] {message}")

# 预设三个级别，得到三个专用函数
log_info = functools.partial(log, "INFO")
log_warn = functools.partial(log, "WARN")
log_error = functools.partial(log, "ERROR")

log_info("服务启动")      # [INFO] 服务启动
log_warn("内存偏高")      # [WARN] 内存偏高
log_error("数据库断连")   # [ERROR] 数据库断连

生活化理解：像给手机设了三个快捷拨号键——1 键打给妈妈，2 键打给快递，3 键打给外卖。号码（参数）提前存好，按一下就行。

五、偏函数 vs 其他方案的对比 ​

固定参数的思路不止偏函数一种，横向对比一下：

方案写法优点缺点
默认参数def int2(x, base=2)直观，有函数名，可写文档每个定制都要写一个 def
lambdaint2 = lambda x: int(x, base=2)简洁无函数名，不适合复杂转发
偏函数int2 = functools.partial(int, base=2)一行搞定，保留原函数信息固定位置参数时容易踩坑
装饰器改造原函数增强功能杀鸡用牛刀，不适合此场景

选用建议：

  • 定制逻辑只是固定参数 → 偏函数最省事；
  • 需要加工参数或返回值 → lambda 或 def；
  • 要起正式名字、写文档、反复使用 → def。

六、常见误区与避坑指南 ​

6.1 误区一：固定位置参数时搞错位置 ​

python
def greet(greeting, name):
    return f"{greeting}，{name}！"

# 想固定 name="小明"？
f = functools.partial(greet, "小明")

>>> f("你好")
'小明，你好！'   # 反了！

原因："小明" 被固定到了第一个位置参数 greeting 上，而不是 name。

正确做法：固定非首位参数，一律用关键字：

python
f = functools.partial(greet, name="小明")

>>> f("你好")
'你好，小明！'

记忆口诀：位置参数焊在左边，想焊右边请报名字。

6.2 误区二：以为偏函数"锁死"了参数 ​

偏函数设定的是新的默认值，不是常量。调用时依然可以覆盖：

python
int2 = functools.partial(int, base=2)
int2('1010')             # 按二进制：10
int2('1010', base=10)    # 覆盖为十进制：1010

如果你发现"改了没生效"，多半是你覆盖时参数名写错了，比如 int2('1010', bases=10)（多了个 s），此时会报 TypeError，仔细看报错信息。

6.3 误区三：给偏函数起名后到处传，忘了它的"出身" ​

python
int2 = functools.partial(int, base=2)

# 半年后，另一个同事看到代码
result = int2('777')   # 他以为这就是 int('777')，结果得到 511

偏函数改变了原函数的默认行为，但名字看起来像普通函数，容易误导不熟悉上下文的读者。

建议：

  • 起见名知意的名字（int2、open_utf8 比 f1、my_int 好得多）；
  • 在模块顶部统一定义偏函数，别散落在各处；
  • 关键场景加一行注释说明固定了哪些参数。

6.4 误区四：用偏函数处理"需要逻辑加工"的参数 ​

偏函数只能原样固定参数值，不能对参数做计算、校验、转换：

python
# ❌ 偏函数做不到：把传入的美元金额换成人民币再调用
# 这种"加工"需求应该用 def 或 lambda
def pay_cny(dollar):
    return pay(dollar * 7.2, currency='CNY')

判断标准：参数是"原样保留"→ 偏函数；参数要"过一道手"→ def/lambda。

6.5 误区五：和装饰器混淆 ​

  • 装饰器：增强函数的行为（加日志、计时、权限），函数参数不变；
  • 偏函数：简化函数的调用（预设参数），函数行为不变。

一个是"给咖啡加奶泡"，一个是"把甜度提前填好"，别搞混了。

七、实战练习 ​

练习 1：进制转换家族 ​

用偏函数基于 int() 创建三个新函数：

  • int2()：默认按二进制转换
  • int8()：默认按八进制转换
  • int16()：默认按十六进制转换

并验证：int2('1010')、int8('17')、int16('FF') 的结果。

参考答案
python
import functools

int2 = functools.partial(int, base=2)
int8 = functools.partial(int, base=8)
int16 = functools.partial(int, base=16)

print(int2('1010'))    # 10
print(int8('17'))      # 15
print(int16('FF'))     # 255

练习 2：定制 print ​

创建一个 print_md 函数，调用它打印多个字符串时，自动用 | 分隔（Markdown 表格风格）：

python
print_md('姓名', '年龄', '城市')
# 期望输出：姓名 | 年龄 | 城市
参考答案
python
import functools

print_md = functools.partial(print, sep=' | ')

print_md('姓名', '年龄', '城市')
# 姓名 | 年龄 | 城市

注意：sep 不是 print 的第一个参数，所以必须用关键字形式固定，不能写成 functools.partial(print, ' | ')——那会把 ' | ' 当成要打印的内容。

练习 3：找出 bug ​

下面代码想实现"比较所有数和 100 的大小，返回最大值"，但结果不对，找出原因并修复：

python
import functools

compare = functools.partial(max, 100)
print(compare(50, 200, 30))   # 期望输出 200
参考答案

其实这段代码输出 200 是对的——max(100, 50, 200, 30) = 200。

但它隐藏着一个坑：因为 100 被固定在最左边，所以 compare(50, 30) 的结果是 100 而不是 50——compare 的语义不是"找出参数里的最大值"，而是"找出参数和 100 里的最大值"。

如果项目里有人误以为 compare 就是普通的 max，就会出 bug。修复建议：起名要达意，比如 max_with_100；或者干脆不要这种"隐藏了一个固定值"的设计。

python
max_with_100 = functools.partial(max, 100)
print(max_with_100(50, 200, 30))   # 200，名字说清了语义

八、小结 ​

  1. 偏函数的作用：用 functools.partial 固定函数的部分参数，生成一个更易调用的新函数；
  2. 固定的是默认值，不是锁死：调用时仍可传值覆盖；
  3. 位置参数被固定在最左边，想固定靠后的参数必须用关键字形式——这是最大的坑；
  4. 典型场景：固定配置参数（超时、编码）、GUI 回调传参、给 map() 适配单参数函数、预设日志级别；
  5. 方案选择：纯固定参数用偏函数，需要加工参数用 lambda/def，要正式文档用 def；
  6. 起名要达意：偏函数改变了默认行为，名字（如 open_utf8）应让人一眼看出"它固定了什么"。

偏函数是 functools 模块送给我们的一个小而美的工具——它不改变函数的能力，只改变函数的"使用体验"。就像奶茶店的模板卡：奶茶还是那杯奶茶，但点单的过程，省心了。

网站备案号:津ICP备15001525号-2