以下是 Python 中 组合函数的 10 个高效技巧，涵盖函数串联、柯里化、装饰器链式调用等场景，助你构建灵活的数据处理流水线：

一、基础组合技巧

1.函数管道（Pipeline）

def add(x):
    return x + 2

def square(x):
    return x ** 2

# 组合函数：先加后平方
pipeline = lambda x: square(add(x))
print(pipeline(3))  # (3+2)^2 = 25

2.通用组合函数

from functools import reduce

def compose(*funcs):
    return reduce(lambda f, g: lambda x: f(g(x)), funcs)

# 从右向左执行：subtract -> double -> add5
func = compose(lambda x: x-3, lambda x: x*2, lambda x: x+5)
print(func(4))  # ((4+5)*2) -3 = 19

二、柯里化（Currying）组合

3.参数分步传递

from functools import partial

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

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(3))    # 27

4.柯里化装饰器

def curry(func):
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        return lambda *a, **kw: curried(*args + a, **{**kwargs, **kw})
    return curried

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

add_5 = add(5)
add_5_6 = add_5(6)
print(add_5_6(7))  # 18

三、装饰器组合

5.多层装饰器链

def bold(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

def italic(func):
    def wrapper():
        return "<i>" + func() + "</i>"
    return wrapper

@bold
@italic
def hello():
    return "Hello"

print(hello())  # <b><i>Hello</i></b>

6.带参数的装饰器组合

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            return [func(*args, **kwargs) for _ in range(n)]
        return wrapper
    return decorator

@repeat(3)
@bold
def greet():
    return "Hi"

print(greet())  # ['<b>Hi</b>', '<b>Hi</b>', '<b>Hi</b>']

四、高阶函数组合

7.Map-Filter 链式处理

numbers = [1, 2, 3, 4, 5]
result = list(
    map(lambda x: x * 2, 
        filter(lambda x: x % 2 == 0, numbers))
)
print(result)  # [4, 8]

8.使用functools.reduce组合

from functools import reduce

# 将多个函数依次应用
functions = [lambda x: x+1, lambda x: x*2, lambda x: x**3]
composed = reduce(lambda f, g: lambda x: f(g(x)), functions)
print(composed(2))  # ((2^3)*2)+1 = 17

五、面向对象组合

9.类方法链式调用

class DataProcessor:
    def __init__(self, data):
        self.data = data
    
    def filter(self, func):
        self.data = list(filter(func, self.data))
        return self
    
    def map(self, func):
        self.data = list(map(func, self.data))
        return self
    
processor = DataProcessor([1, 2, 3, 4])
result = processor.filter(lambda x: x%2==0).map(lambda x: x*2).data
print(result)  # [4, 8]

六、实用工具库

10.使用toolz库

from toolz import compose, pipe

# compose: 从右向左执行
calc = compose(lambda x: x-5, lambda x: x*3, lambda x: x+2)
print(calc(4))  # (4+2)*3-5=13

# pipe: 从左向右执行
result = pipe(4, lambda x: x+2, lambda x: x*3, lambda x: x-5)
print(result)  # 同上

组合函数最佳实践

1. 保持函数纯净：避免副作用，确保组合安全
2. 合理命名中间函数：增强可读性
3. 控制组合深度：超过5层的组合建议拆分
4. 性能监控：复杂组合需用 timeit 测试

典型应用场景

1. 数据清洗流水线：

clean_data = compose(
    remove_outliers, 
    fill_missing_values,
    normalize
)(raw_data)

API请求处理：

process_response = compose(
    parse_json,
    validate_schema,
    log_result
)

图像处理链：

transform_image = compose(
    resize(800, 600),
    apply_filter("grayscale"),
    add_watermark
)

掌握这些组合技巧后，你的代码将更模块化、可维护性更强，轻松应对复杂的数据处理需求！