Python 函数式编程怎么用才适合实际项目？

Python 函数式编程先解决什么问题

在 Python 里谈函数式编程，不是要把所有代码都写成一串看不懂的 lambda。它更适合处理这类问题：一批数据进来，经过过滤、转换、排序、聚合，最后得到一个新结果。

比如清洗接口返回的订单、统计日志里的错误类型、把配置项按规则合并。只要中间步骤能拆成几个独立的小函数，函数式写法就能让数据流向更清楚，也更容易测试。

Python 不是纯函数式语言，所以不用排斥循环、类和可变对象。更实际的做法是：在关键的数据处理逻辑里多用纯函数、少改共享状态，必要时用 map、filter、reduce、生成器和装饰器把重复逻辑收起来。

两个基础习惯：纯函数和不可变数据

纯函数有两个特点：同样的输入总是得到同样的输出；函数内部不修改外部状态。这个习惯看起来朴素，但在排查线上问题时很省心，因为你不用猜某个全局变量是不是被别处改过。

python
# 纯函数：只依赖参数，不改外部状态
def add_tax(price, rate):
    return round(price * (1 + rate), 2)

print(add_tax(100, 0.06))  # 106.0
print(add_tax(100, 0.06))  # 106.0

# 非纯函数：依赖并修改外部状态
total = 0

def add_to_total(amount):
    global total
    total += amount
    return total

不可变数据的意思不是所有地方都必须用元组，而是尽量别在函数里偷偷改传进来的对象。尤其是列表、字典这种可变对象，修改前最好明确创建新对象。

python
# 更稳妥：返回新列表
def append_item(items, item):
    return items + [item]

original = [1, 2, 3]
new_items = append_item(original, 4)

print(original)   # [1, 2, 3]
print(new_items)  # [1, 2, 3, 4]

写业务代码时，这个区别很常见。比如函数接收一份配置，如果直接往里面塞默认值，调用方后面可能拿到一份已经被改过的配置；返回新配置就清楚得多。

map、filter、reduce、sorted 分别适合什么场景

这几个函数是 Python 函数式编程里最常见的工具。别把它们当成必须使用的写法，先看语义是否合适。

工具	适合场景	常见替代
map	每个元素都做同一种转换	列表推导式
filter	按条件保留一部分元素	带 if 的列表推导式
reduce	把多个值折叠成一个值	sum、max、普通循环
sorted	排序并返回新列表	list.sort() 会原地修改

map 适合表达“逐个转换”：

python
numbers = [1, 2, 3, 4, 5]

squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

left = [1, 2, 3]
right = [4, 5, 6]
print(list(map(lambda x, y: x + y, left, right)))  # [5, 7, 9]

filter 适合表达“筛掉不需要的”：

python
numbers = range(1, 11)

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4, 6, 8, 10]

words = ["apple", "banana", "cherry", "date"]
long_words = list(filter(lambda word: len(word) > 5, words))
print(long_words)  # ['banana', 'cherry']

reduce 适合做累积，不过要谨慎。能用 sum()、max()、min() 表达清楚时，不必强行用 reduce。

python
from functools import reduce

numbers = [1, 2, 3, 4, 5]

print(reduce(lambda x, y: x + y, numbers))      # 15
print(reduce(lambda x, y: x * y, numbers))      # 120
print(reduce(lambda x, y: x + y, numbers, 10))  # 25，初始值为 10

sorted 的好处是不会改原列表，配合 key 很适合处理对象或字典列表。

python
students = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Charlie", "age": 30},
]

by_age = sorted(students, key=lambda item: item["age"])
print(by_age[0])  # {'name': 'Bob', 'age': 20}

lambda 要短，复杂逻辑交给命名函数

lambda 是匿名函数，适合一眼能看懂的小逻辑，比如取字段、简单计算、简单条件。它只能写表达式，不能写多行语句。

python
students = [("Alice", 25), ("Bob", 20), ("Charlie", 30)]

sorted_students = sorted(students, key=lambda item: item[1])
print(sorted_students)

如果逻辑开始变长，就别硬塞进 lambda。命名函数不仅更好读，也方便单独测试。

python
# 不推荐：条件嵌套太多
score_to_level = lambda score: "A" if score >= 90 else "B" if score >= 80 else "C"

# 更清楚：写成普通函数
def score_to_level(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    return "C"

一个简单判断：如果你需要回头数括号，或者要解释这个 lambda 到底在做什么，那它就该变成普通函数了。

列表推导式和生成器表达式更有 Python 味

很多时候，列表推导式比 map 和 filter 更直观。尤其是转换和过滤同时出现时，它读起来更接近自然语言。

python
numbers = [1, 2, 3, 4, 5]

even_squared = [x ** 2 for x in numbers if x % 2 == 0]
print(even_squared)  # [4, 16]

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

数据量大时，生成器表达式更合适。它不会一次性把所有结果塞进内存，而是用到一个算一个。

python
large_squares = (x ** 2 for x in range(1_000_000))

for value in large_squares:
    if value > 100:
        print(value)
        break

处理日志、文件行、分页接口时，生成器很实用。它让“数据可能很多”这件事不必一开始就变成内存压力。

装饰器：把横切逻辑从业务函数里拿走

装饰器本质上也是高阶函数：接收一个函数，返回一个新函数。它适合处理日志、鉴权、重试、计时、缓存这类“很多函数都需要，但又不属于核心业务”的逻辑。

python
from functools import wraps
import time


def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        cost = time.perf_counter() - start
        print(f"{func.__name__} took {cost:.4f}s")
        return result
    return wrapper


@timer
def load_items():
    return [x for x in range(10000)]

这里的 @wraps 很重要，它会保留原函数的 __name__、文档字符串等元数据。没有它，调试、日志和一些框架反射逻辑可能会看到一堆 wrapper。

带参数的装饰器也很常见，比如做简单重试：

python
from functools import wraps


def retry(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for _ in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as error:
                    last_error = error
            raise last_error
        return wrapper
    return decorator

partial：提前固定一部分参数

functools.partial 可以把一个函数的部分参数先固定住，得到一个更具体的新函数。它比自己写一堆薄封装函数更省事。

python
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(5))    # 125

在项目里，它常用于给通用函数预置上下文。

python
from functools import partial


def format_message(level, service, message):
    return f"[{level}] {service}: {message}"

api_error = partial(format_message, "ERROR", "payment-api")
print(api_error("timeout"))  # [ERROR] payment-api: timeout

如果参数越来越多，partial 也可能让人迷糊。这个时候改成一个带清晰名字的函数，反而更直接。

用小函数拼出数据处理管道

函数式写法最舒服的场景，是把数据处理拆成几个小步骤。每个函数只做一件事，输入输出都清楚，组合起来就是一条管道。

python
from functools import reduce

orders = [
    {"id": 1, "status": "paid", "amount": 120, "country": "CN"},
    {"id": 2, "status": "cancelled", "amount": 80, "country": "US"},
    {"id": 3, "status": "paid", "amount": 260, "country": "CN"},
]


def is_paid(order):
    return order["status"] == "paid"


def to_amount(order):
    return order["amount"]


def add(left, right):
    return left + right

paid_orders = filter(is_paid, orders)
paid_amounts = map(to_amount, paid_orders)
total_amount = reduce(add, paid_amounts, 0)

print(total_amount)  # 380

上面这段可以继续写得更 Pythonic：

python
total_amount = sum(
    order["amount"]
    for order in orders
    if order["status"] == "paid"
)

这不是说 map/filter/reduce 不好，而是 Python 里有多种表达方式。短逻辑用推导式，复用逻辑拆成命名函数，复杂聚合用普通循环，都很正常。

函数组合和柯里化适合少量使用

函数组合就是把多个函数接起来，前一个函数的输出作为后一个函数的输入。它能让处理流程更集中。

python
def compose(*functions):
    def inner(value):
        result = value
        for func in reversed(functions):
            result = func(result)
        return result
    return inner


def add_one(x):
    return x + 1


def multiply_two(x):
    return x * 2


def square(x):
    return x ** 2

pipeline = compose(square, multiply_two, add_one)
print(pipeline(3))  # 64

柯里化是把多参数函数变成一连串单参数函数。它在一些函数式语言里很常见，在 Python 里偶尔有用，但不要为了形式感到处写。

python
def curry(func):
    def curried(*args):
        if len(args) >= func.__code__.co_argcount:
            return func(*args)
        return lambda *more: curried(*(args + more))
    return curried


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

print(add(1)(2)(3))  # 6

实际项目里，partial 往往比通用柯里化更容易被团队接受。组合和柯里化适合用在边界清晰的数据转换上，不适合把普通业务流程绕成谜题。

记忆化：让重复计算少做几次

如果一个函数是纯函数，而且同样的参数会反复出现，就可以考虑记忆化。Python 标准库里的 lru_cache 已经够用。

python
from functools import lru_cache


@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(100))
print(fibonacci.cache_info())

手写一个简化版也不难：

python
def memoize(func):
    cache = {}

    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]

    return wrapper

不过缓存不是免费午餐。参数必须可哈希，缓存会占内存，数据有时效性时还要考虑失效策略。像“按用户权限查询结果”这类函数，缓存前要先确认参数是否完整表达了影响结果的所有条件。

函数式写法带来的几个实际好处

第一是可测试。纯函数不依赖数据库、全局变量、当前时间，单测只需要准备输入和断言输出。

python
def calculate_discount(price, discount_rate):
    return price * (1 - discount_rate)

assert calculate_discount(100, 0.2) == 80
assert calculate_discount(50, 0) == 50

第二是可预测。函数不偷偷修改外部对象，调用前后状态更容易判断。多人协作时，这比少写两行代码更重要。

第三是更容易并行。没有共享状态的函数，放进线程池或进程池时少很多锁和竞态问题。

python
from concurrent.futures import ThreadPoolExecutor


def process_item(item):
    return item ** 2

items = list(range(1000))

with ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(process_item, items))

第四是复用。小函数边界清楚，就能在不同管道里重新组合。今天用于订单统计，明天用于报表导出，不需要复制一份差不多的循环。

什么时候不要过度使用函数式写法

函数式编程很好用，但过度使用会把 Python 写得不像 Python。下面几种情况，普通写法通常更合适。

• lambda 里出现多层条件判断，改成命名函数。
• reduce 的累积逻辑需要读半天，改成 for 循环。
• 为了组合而组合，导致调试时看不到中间变量。
• 明明需要维护一组有生命周期的状态，却强行拆成很多无状态函数。
• 团队成员普遍不熟悉柯里化，却把核心业务写成连续调用。

一个实用原则：如果函数式写法让数据流更清楚，就用；如果它只是让代码显得“高级”，就停一下。

落到 Python 项目里怎么用

在 Python 项目里，函数式编程更像一套写代码的习惯，而不是一套必须遵守的规矩。纯函数让逻辑更稳定，不可变思路减少意外修改；map、filter、reduce、sorted 适合表达数据转换；列表推导式和生成器让代码更贴近 Python；装饰器、partial、组合和记忆化则适合处理复用和性能问题。

保留循环，保留类，也保留清晰的中间变量。真正有价值的函数式写法，是让下一位读代码的人更快明白：数据从哪里来，经过了什么规则，最后变成了什么。