一、引言

如果你写过 functools.partial，或者曾经用闭包"锁定"一个参数，那你其实已经在不知不觉中使用了**柯里化（Currying）**的思想。这个名字来源于数学家 Haskell Curry，而它背后的思想极为简洁：将接受多个参数的函数，转化为一系列只接受一个参数的函数。

从 Python 的视角出发，柯里化不仅是一种函数式编程技巧，更是深入理解闭包、高阶函数与"函数是对象"这三件事的绝佳切入点。

二、什么是柯里化

2.1 原始定义

在数学和 lambda 演算中，柯里化的定义是：

将一个接受 N 个参数的函数 f(a, b, c) 转化为 f(a)(b)(c) —— 即接受第一个参数返回新函数，新函数接受第二个参数返回下一个新函数，直到收集完所有参数时执行原始逻辑。

2.2 一个直观的例子

从一个简单的加法函数开始：

1
2
3
4
5
# 普通写法：一次接受两个参数
def add(a, b):
    return a + b

print(add(3, 5))  # 输出：8

柯里化之后：

1
2
3
4
5
6
7
8
9
# 柯里化写法：每次只接受一个参数
def curried_add(a):
    def inner(b):
        return a + b
    return inner

add_3 = curried_add(3)   # 返回一个"加3"的函数
print(add_3(5))           # 输出：8
print(add_3(10))          # 输出：13

关键变化：add(a, b) 变成了 curried_add(a)(b)。第一个括号拿到 a 并返回一个闭包，第二个括号拿到 b 并执行真正的加法。

三、手动实现柯里化

3.1 两层柯里化

1
2
3
4
5
6
7
8
9
10
def multiply(a):
    def by(b):
        return a * b
    return by

double = multiply(2)
triple = multiply(3)

print(double(7))   # 输出：14
print(triple(7))   # 输出：21

这是最朴素的手工柯里化：每次嵌套一层 def，捕获一个参数，返回一个闭包。

3.2 三层柯里化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def power(a):
    def to_the(b):
        def modulo(c):
            return (a ** b) % c
        return modulo
    return to_the

# 调用方式：power(2)(10)(7)
print(power(2)(10)(7))  # 输出：1024 % 7 = 2

# 也可以分步构建
base_2 = power(2)
square = base_2(2)      # 2 的平方
cube = base_2(3)        # 2 的立方
print(square(5))         # 输出：4 % 5 = 4
print(cube(5))           # 输出：8 % 5 = 3

每一步调用固定一个参数，返回一个"更具体"的函数。这就是柯里化的精髓——逐步特化（Progressive Specialization）。

四、通用柯里化装饰器

如果不想每次都手动嵌套，可以写一个自动柯里化装饰器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from functools import wraps
from inspect import signature

def curry(func):
    @wraps(func)
    def curried(*args):
        sig = signature(func)
        if len(args) >= len(sig.parameters):
            return func(*args)
        def wrapper(*more_args):
            return curried(*(args + more_args))
        return wrapper
    return curried

@curry
def greet(greeting, name, punctuation):
    return f"{greeting}, {name}{punctuation}"

print(greet("Hello")("World")("!"))  # 输出：Hello, World!

say_hello = greet("Hello")
say_hello_to_tom = say_hello("Tom")
print(say_hello_to_tom("!"))          # 输出：Hello, Tom!
print(say_hello_to_tom("."))          # 输出：Hello, Tom.

这个装饰器利用 inspect.signature 检测函数的参数个数：参数不够时返回一个新函数等待更多参数，参数够了就执行。

不过在实际项目中，使用 functools.partial 通常是更 Pythonic 的选择（后文详述）。

五、柯里化 vs 偏函数

很多人混淆这两个概念。它们确实相关，但有本质区别：

特性 柯里化（Currying） 偏函数（Partial Application）
定义 将 N 元函数转为 N 个一元函数链 固定一部分参数，返回剩余参数的函数
参数传递 每次固定一个参数 一次可以固定任意多个参数
调用方式 f(a)(b)(c) f_fixed(b, c)
Python 工具 手动嵌套 / 装饰器 functools.partial

用代码说明区别：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from functools import partial

def add(a, b, c):
    return a + b + c

# 偏函数：一次固定两个参数
add_1_and_2 = partial(add, 1, 2)
print(add_1_and_2(3))  # 输出：6

# 柯里化：每次一个参数
def curried_add(a):
    def inner1(b):
        def inner2(c):
            return a + b + c
        return inner2
    return inner1

add_1 = curried_add(1)
add_1_and_2 = add_1(2)
print(add_1_and_2(3))  # 输出：6

偏函数更灵活（想固定几个就固定几个），柯里化更严格（强制每次一个）。Python 中偏函数更加常见和实用。

六、实战场景

6.1 构建可复用的小工具函数

1
2
3
4
5
6
7
8
def make_format(template):
    def formatter(**kwargs):
        return template.format(**kwargs)
    return formatter

info_printer = make_format("[{level}] {message} - {time}")
print(info_printer(level="INFO", message="服务启动", time="10:00"))
# 输出：[INFO] 服务启动 - 10:00

6.2 管道式数据处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def pipe(*funcs):
    def runner(data):
        result = data
        for f in funcs:
            result = f(result)
        return result
    return runner

def multiply_by(n):
    return lambda x: x * n

def add_n(n):
    return lambda x: x + n

process = pipe(
    multiply_by(2),
    add_n(10),
    multiply_by(3)
)

print(process(5))  # 输出：((5*2)+10)*3 = 60

6.3 配置化函数工厂

1
2
3
4
5
6
7
8
9
10
11
12
def create_api_client(base_url):
    def with_token(token):
        def make_request(endpoint):
            return f"GET {base_url}/{endpoint} (Auth: {token})"
        return make_request
    return with_token

client = create_api_client("https://api.example.com")
authenticated = client("sk-xxxxx")

print(authenticated("users"))       # GET https://api.example.com/users (Auth: sk-xxxxx)
print(authenticated("posts/42"))    # GET https://api.example.com/posts/42 (Auth: sk-xxxxx)

每一步柯里化添加一层配置，最终的函数只关心变化的部分——这正是依赖注入的一种朴素实现。

七、与 C++ 的对比

C++ 没有内置的柯里化语法，但可以用 lambda 和 std::bind 逼近：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// C++: 用嵌套 lambda 模拟柯里化
auto curried_add = [](int a) {
    return [a](int b) {
        return [a, b](int c) {
            return a + b + c;
        };
    };
};

int result = curried_add(1)(2)(3);  // 输出：6

// C++: 偏函数（更常见）
using namespace std::placeholders;
auto add = [](int a, int b, int c) { return a + b + c; };
auto add_1_and_2 = std::bind(add, 1, 2, _1);
int result2 = add_1_and_2(3);  // 输出：6

对比总结：

方面 Python 柯里化 C++ 模拟
语法复杂度 嵌套 def，简洁 嵌套 lambda，类型声明繁琐
闭包捕获 自动捕获外框架 显式捕获列表 [a, b]
类型安全 动态类型，灵活 静态类型，编译期检查
实用推荐 functools.partial 更常用 std::bind 或直接 lambda

八、柯里化的适用边界

什么时候用

  1. 逐步构建配置：一步步锁定 base_url、token、超时时间等配置参数
  2. 函数组合：配合 pipe、compose 构建数据处理管道
  3. 延迟求值：先组装逻辑链，最后一刻传入核心数据执行

什么时候不用

  1. 过度抽象：两层以上柯里化通常会让代码可读性急剧下降。greet("Hello")("World")("!") 远没有 greet("Hello", "World", "!") 直观
  2. 团队不熟悉函数式范式：维护成本会高于收益
  3. 性能敏感场景：每次柯里化都创建了新函数对象和闭包，有一定开销

Python 的哲学是"显式优于隐式，简单优于复杂"。偏函数（partial）和默认参数往往比柯里化更适合日常使用。

九、总结

柯里化是一种将多参数函数转化为单参数函数链的技术，它的核心机制依赖于闭包——每个中间函数都"记住"了之前传入的参数，等待最后一个参数到来时执行真正逻辑。

三个关键收获：

  1. 思想来源：源自 lambda 演算，Haskell Curry 命名，是现代函数式编程的基石
  2. Python 实现：靠闭包逐层捕获参数，可以手动嵌套也可以用装饰器自动执行
  3. 实践取舍：理论上优雅，实践中偏函数（functools.partial）通常更实用、更 Pythonic

柯里化的价值不仅在于"怎么写"，更在于它让你重新理解了"函数是什么"——函数不是只能一次性吃完所有参数，它也可以分批次、分阶段地"消化"参数。这种"将复杂拆解为序列"的思维方式，才是函数式编程给予我们的真正财富。