Python 后端开发技术博客专栏 | 第 02 篇 函数式编程与 Python 魔法 -- 闭包、装饰器、高阶函数

难度等级： 中级-高级
适合读者： 有 Python 基础的开发者，准备面试的中高级工程师
前置知识： 第 01 篇《Python 数据结构全解析》

---

导读

在 Python 的世界里，函数不仅仅是"执行一段代码"的载体 -- 它是一等公民（First-Class Citizen），可以被赋值给变量、作为参数传递、作为返回值返回。这一特性催生了 Python 中最强大的三个编程范式：闭包、装饰器和高阶函数。

如果你用过 FastAPI，那么 @app.get("/") 就是装饰器；如果你用过 sorted(users, key=lambda u: u.age)，那就是高阶函数；如果你写过函数工厂来动态生成回调，那就是闭包。它们渗透在 Python 开发的方方面面，也是面试中出镜率最高的知识点之一。

但很多开发者在以下问题上会卡壳：

• [lambda x: i*x for i in range(4)] 为什么全部返回 300 而不是 [0, 100, 200, 300]？
• 带参数的装饰器为什么要三层嵌套？不用 functools.wraps 会怎样？
• 装饰器堆叠 @A @B @C 的执行顺序到底是什么？
• 什么时候该用闭包，什么时候该用类？

本文将从底层原理到生产实战，系统性地拆解这三大核心机制，帮助你彻底掌握 Python 函数式编程的精髓。

---

学习目标

读完本文后，你将能够：

1. 解释 Python 中"函数是一等公民"的含义，理解 callable 协议和 __call__ 方法
2. 掌握闭包形成的三个必要条件，能准确分析闭包变量的延迟绑定行为
3. 从无参装饰器到带参装饰器再到类装饰器，完整实现装饰器体系
4. 理解 functools.wraps 的必要性，掌握装饰器堆叠的执行顺序
5. 熟练使用 map、filter、reduce、sorted、functools.partial 等高阶函数
6. 在面试中自信手写带参数的装饰器，解答闭包相关的经典陷阱题
7. 在实际项目中实现缓存、重试、权限校验等生产级装饰器

---

一、函数是一等公民

1.1 什么是一等公民

在 Python 中，函数与 int、str、list 一样，都是对象。所谓"一等公民"，意味着函数可以：

1. 赋值给变量
2. 作为参数传递给其他函数
3. 作为函数的返回值
4. 存储在数据结构中（如列表、字典）

# 1. 赋值给变量
def greet(name):
    return f"Hello, {name}"

say_hello = greet  # 函数赋值给变量，不加括号
print(say_hello("Alice"))  # Hello, Alice
print(type(say_hello))     # <class 'function'>


# 2. 作为参数传递
def apply(func, value):
    return func(value)

print(apply(len, "Python"))   # 6
print(apply(str.upper, "hi")) # HI


# 3. 作为返回值
def make_greeter(greeting):
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hello = make_greeter("Hello")
nihao = make_greeter("你好")
print(hello("Bob"))   # Hello, Bob!
print(nihao("小明"))  # 你好, 小明!


# 4. 存储在数据结构中
operations = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
    "mul": lambda a, b: a * b,
}
print(operations["add"](3, 5))  # 8

1.2 callable 协议与 __call__

Python 判断一个对象是否"可调用"，看的是它是否实现了 __call__ 方法。函数、类、实现了 __call__ 的实例，都是可调用的：

# 函数天然可调用
def foo():
    pass
print(callable(foo))  # True

# 类也是可调用的（调用类就是创建实例）
print(callable(int))   # True
print(callable(list))  # True

# 自定义可调用对象
class Adder:
    def __init__(self, n):
        self.n = n

    def __call__(self, x):
        return self.n + x

add_5 = Adder(5)
print(add_5(10))         # 15
print(callable(add_5))   # True

# 普通实例不可调用
class Plain:
    pass

p = Plain()
print(callable(p))  # False

实际应用 ：__call__ 使得类实例可以像函数一样使用，这是实现类装饰器的基础（后文详述）。

1.3 函数对象的内省

每个函数对象都携带着丰富的元信息：

def calculate_area(radius, pi=3.14159):
    """计算圆的面积"""
    return pi * radius ** 2

# 函数的元信息
print(calculate_area.__name__)        # calculate_area
print(calculate_area.__doc__)         # 计算圆的面积
print(calculate_area.__defaults__)    # (3.14159,)
print(calculate_area.__code__.co_varnames)  # ('radius', 'pi')
print(calculate_area.__module__)      # __main__

# __code__ 对象包含字节码信息
code = calculate_area.__code__
print(code.co_argcount)      # 2（参数个数）
print(code.co_freevars)      # ()（自由变量，闭包相关）

这些元信息在后面讲 functools.wraps 时至关重要 -- 装饰器如果不妥善处理，会破坏这些信息。

---

二、闭包（Closure）机制

2.1 闭包的定义与三个必要条件

闭包是指一个内部函数 能够访问并"记住"其外部函数作用域中的变量，即使外部函数已经执行完毕返回。

形成闭包必须同时满足三个条件：

1. 函数嵌套：在一个函数（外函数）内部定义另一个函数（内函数）
2. 引用自由变量：内函数引用了外函数的局部变量
3. 返回内函数：外函数将内函数作为返回值返回

def outer(x):          # 外函数
    def inner(y):      # 条件1：函数嵌套
        return x + y   # 条件2：引用外函数变量 x
    return inner        # 条件3：返回内函数

# 创建闭包
add_10 = outer(10)  # x=10 被"捕获"
add_20 = outer(20)  # x=20 被"捕获"

print(add_10(5))   # 15
print(add_20(5))   # 25

# 验证闭包捕获的变量
print(add_10.__closure__)             # (<cell at 0x...>,)
print(add_10.__closure__[0].cell_contents)  # 10
print(add_10.__code__.co_freevars)    # ('x',)

底层原理 ：当 Python 发现内函数引用了外函数的局部变量时，会将该变量从栈上的局部变量提升为 cell 对象 。外函数返回后，这个 cell 对象不会被销毁，而是被绑定到内函数的 __closure__ 属性上，从而"延长"了变量的生命周期。

2.2 闭包的实际应用

应用一：函数工厂

def make_multiplier(factor):
    """根据不同的因子，生成不同的乘法函数"""
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15

应用二：状态计数器

def make_counter(start=0):
    """创建一个带状态的计数器"""
    count = start

    def counter():
        nonlocal count  # 声明修改外部变量
        count += 1
        return count

    return counter

c1 = make_counter()
print(c1())  # 1
print(c1())  # 2
print(c1())  # 3

c2 = make_counter(100)
print(c2())  # 101 -- 独立的状态

应用三：配置化回调

def make_logger(level):
    """生成指定级别的日志函数"""
    def logger(message):
        print(f"[{level}] {message}")
    return logger

info = make_logger("INFO")
error = make_logger("ERROR")

info("Server started")    # [INFO] Server started
error("Connection lost")  # [ERROR] Connection lost

2.3 经典陷阱：延迟绑定（Late Binding）

这是 Python 面试中最经典的闭包陷阱题：

def multiply():
    return [lambda x: i * x for i in range(4)]

result = [m(100) for m in multiply()]
print(result)  # [300, 300, 300, 300] -- 不是 [0, 100, 200, 300]！

为什么全是 300？

这里有两个关键点：

1. 列表推导式 [lambda x: i * x for i in range(4)] 创建了 4 个 lambda 函数，它们都引用了同一个变量 i
2. 闭包捕获的是变量本身 （引用），不是变量在创建时的值 。当 lambda 真正被调用时，for 循环已经结束，i 的最终值是 3

所以 4 个 lambda 在调用时都查找变量 i，得到的都是 3，因此结果全是 3 * 100 = 300。

解决方案一：默认参数捕获当前值

def multiply_fixed_1():
    return [lambda x, i=i: i * x for i in range(4)]
    #                   ^^^ 默认参数在创建时求值

print([m(100) for m in multiply_fixed_1()])
# [0, 100, 200, 300]

原理：Python 的默认参数值在函数定义时 就计算好了，所以 i=i 把每次循环的当前值"快照"到了各自的默认参数中。

解决方案二：使用生成器

def multiply_fixed_2():
    for i in range(4):
        yield lambda x: i * x

print([m(100) for m in multiply_fixed_2()])
# [0, 100, 200, 300]

原理：生成器的 yield 会在每次迭代时暂停执行。当 m(100) 被调用时，生成器还停留在当前的 i 值处，还没有进入下一次迭代。

解决方案三：functools.partial

from functools import partial

def multiply_fixed_3():
    def mul(i, x):
        return i * x
    return [partial(mul, i) for i in range(4)]

print([m(100) for m in multiply_fixed_3()])
# [0, 100, 200, 300]

2.4 nonlocal 关键字

在闭包中，内函数可以读取 外函数的变量，但如果要修改 它（重新绑定），必须使用 nonlocal 声明：

def counter():
    count = 0

    def increment():
        # count += 1  # 不加 nonlocal 会报 UnboundLocalError
        nonlocal count
        count += 1
        return count

    return increment

c = counter()
print(c())  # 1
print(c())  # 2

为什么不加 nonlocal 会报错？

因为 count += 1 等价于 count = count + 1，Python 看到赋值操作后会将 count 视为局部变量。但右边的 count + 1 在局部作用域中还没有被赋值，所以抛出 UnboundLocalError。

nonlocal 告诉 Python："这个变量不是局部的，去外层闭包作用域中找它。"

2.5 闭包 vs 类实例

闭包和类实例都可以用来封装状态，如何选择？

# 闭包实现
def make_accumulator(initial=0):
    total = initial
    def add(value):
        nonlocal total
        total += value
        return total
    return add

acc = make_accumulator(100)
print(acc(10))  # 110
print(acc(20))  # 130


# 类实现
class Accumulator:
    def __init__(self, initial=0):
        self.total = initial

    def add(self, value):
        self.total += value
        return self.total

acc2 = Accumulator(100)
print(acc2.add(10))  # 110
print(acc2.add(20))  # 130

选择建议：

特征	闭包	类
状态简单（1-2 个变量）	优先	可以
状态复杂（多个变量 + 方法）	不推荐	优先
需要序列化/pickle	不适合	适合
作为回调传递	优先（更轻量）	可以（需 __call__）
需要继承/多态	不可能	优先

实际开发中，如果只需要一个可调用对象+少量状态，闭包更简洁；如果需要多个方法和复杂的状态管理，类更合适。

---

三、装饰器（Decorator）体系

装饰器是闭包最重要的应用。它的核心思想是：在不修改目标函数代码的前提下，为其增加额外功能。

3.1 无参装饰器

最基本的装饰器接受一个函数，返回一个新函数：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"[LOG] 调用 {func.__name__}，参数: args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[LOG] {func.__name__} 返回: {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

# @log_decorator 等价于: add = log_decorator(add)
print(add(3, 5))

输出：

[LOG] 调用 add，参数: args=(3, 5), kwargs={}
[LOG] add 返回: 8
8

执行流程拆解：

1. Python 读到 @log_decorator，执行 add = log_decorator(add)
2. log_decorator(add) 返回 wrapper 函数
3. 此时 add 这个名字指向了 wrapper
4. 调用 add(3, 5)，实际执行的是 wrapper(3, 5)
5. wrapper 内部调用了原始的 func(3, 5)（即原始的 add）

3.2 functools.wraps -- 保留函数元信息

无参装饰器有一个严重的副作用：被装饰后的函数丢失了原始的元信息：

def log_decorator_bad(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@log_decorator_bad
def add(a, b):
    """两数相加"""
    return a + b

# 元信息丢失了！
print(add.__name__)  # wrapper（不是 add）
print(add.__doc__)   # None（不是 "两数相加"）

这会导致调试困难（堆栈信息显示 wrapper 而非 add），也会破坏依赖函数名/文档的框架功能（如 Flask 路由、Sphinx 文档生成）。

解决方案：functools.wraps

import functools

def log_decorator_good(func):
    @functools.wraps(func)  # 关键：将 func 的元信息拷贝到 wrapper
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@log_decorator_good
def add(a, b):
    """两数相加"""
    return a + b

# 元信息保留了
print(add.__name__)      # add
print(add.__doc__)       # 两数相加
print(add.__wrapped__)   # <function add at 0x...>（原始函数的引用）

functools.wraps 本身也是一个装饰器，它将被装饰函数的 __name__、__doc__、__module__、__qualname__、__annotations__、__dict__ 等属性拷贝到 wrapper 上，并设置 __wrapped__ 属性指向原始函数。

原则：编写装饰器时，始终使用 functools.wraps。

3.3 带参数的装饰器

当装饰器本身需要配置参数时（如指定日志级别、重试次数），需要三层嵌套：

import functools
import time

def timing_logger(log_level="INFO"):
    """带参数的装饰器：统计函数执行耗时并打印日志"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            start = time.perf_counter()
            try:
                result = func(*args, **kwargs)
                elapsed = time.perf_counter() - start
                print(f"[{log_level}] {func.__name__} 执行耗时: {elapsed:.4f}s")
                return result
            except Exception as e:
                elapsed = time.perf_counter() - start
                print(f"[ERROR] {func.__name__} 执行失败, "
                      f"耗时: {elapsed:.4f}s, 错误: {e}")
                raise
        return wrapper
    return decorator

@timing_logger(log_level="DEBUG")
def slow_function():
    time.sleep(0.1)
    return "done"

result = slow_function()
# [DEBUG] slow_function 执行耗时: 0.1003s

三层嵌套的逻辑：

第一层：timing_logger(log_level="DEBUG")
    → 返回 decorator 函数（此时 log_level 被闭包捕获）

第二层：decorator(slow_function)
    → 返回 wrapper 函数（此时 func 被闭包捕获）

第三层：wrapper(*args, **kwargs)
    → 实际执行逻辑，可以访问 log_level 和 func

展开后等价于：
slow_function = timing_logger(log_level="DEBUG")(slow_function)

3.4 类装饰器

除了函数，类也可以作为装饰器，利用 __call__ 方法使实例可调用：

import functools

class CountCalls:
    """统计函数被调用次数的类装饰器"""

    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.call_count = 0

    def __call__(self, *args, **kwargs):
        self.call_count += 1
        print(f"[CountCalls] {self.func.__name__} 已被调用 {self.call_count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello(name):
    return f"Hello, {name}!"

print(say_hello("Alice"))  # [CountCalls] say_hello 已被调用 1 次 \n Hello, Alice!
print(say_hello("Bob"))    # [CountCalls] say_hello 已被调用 2 次 \n Hello, Bob!
print(say_hello.call_count)  # 2 -- 可以直接访问状态

类装饰器的优势在于可以方便地维护状态（如调用次数），并且支持更复杂的接口（多个方法）。

3.5 装饰器堆叠的执行顺序

当多个装饰器堆叠时，执行顺序是自下而上装饰，自上而下执行：

import functools

def decorator_a(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("A: before")
        result = func(*args, **kwargs)
        print("A: after")
        return result
    return wrapper

def decorator_b(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("B: before")
        result = func(*args, **kwargs)
        print("B: after")
        return result
    return wrapper

def decorator_c(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("C: before")
        result = func(*args, **kwargs)
        print("C: after")
        return result
    return wrapper

@decorator_a
@decorator_b
@decorator_c
def hello():
    print("hello!")

hello()

输出：

A: before
B: before
C: before
hello!
C: after
B: after
A: after

解析：

装饰顺序（自下而上）：
  hello = decorator_a(decorator_b(decorator_c(hello)))

执行顺序（自上而下进入，自下而上返回）：
  → A 的 before
    → B 的 before
      → C 的 before
        → 原始 hello()
      ← C 的 after
    ← B 的 after
  ← A 的 after

这就像洋葱模型 -- 请求从外层进入，到达核心后再从内层返回。这与 Django/FastAPI 的中间件执行顺序是相同的原理。

3.6 常用内置装饰器速览

装饰器	用途	示例
@property	将方法变为属性访问	obj.name 代替 obj.get_name()
@staticmethod	静态方法（不需要 self/cls）	工具函数放在类命名空间
@classmethod	类方法（第一个参数是 cls）	工厂方法、替代构造函数
@abstractmethod	抽象方法（子类必须实现）	定义接口约束
@functools.lru_cache	自动缓存函数返回值	递归、重复计算加速
@functools.wraps	保留被装饰函数的元信息	编写装饰器时必备
@functools.singledispatch	单分派泛函数	根据参数类型分发
@dataclasses.dataclass	自动生成 __init__ 等方法	数据类定义

3.7 实战一：缓存装饰器

import functools

def memoize(func):
    """手写缓存装饰器（简化版 lru_cache）"""
    cache = {}

    @functools.wraps(func)
    def wrapper(*args):
        if args in cache:
            print(f"  [缓存命中] {func.__name__}{args}")
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result

    wrapper.cache = cache  # 暴露缓存供外部查看
    wrapper.cache_clear = lambda: cache.clear()
    return wrapper

@memoize
def fibonacci(n):
    """递归计算斐波那契数列"""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55
print(f"缓存条目数: {len(fibonacci.cache)}")  # 11

# 对比：不使用缓存的递归 fibonacci(35) 需要数秒
# 使用缓存后几乎瞬时完成

生产环境推荐直接使用 functools.lru_cache：

import functools

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

print(fibonacci_prod(100))  # 354224848179261915075
print(fibonacci_prod.cache_info())
# CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)

lru_cache 还支持 maxsize 参数控制缓存大小，当缓存满时自动淘汰最久未使用的条目（LRU 策略）。

3.8 实战二：重试装饰器（指数退避）

import functools
import time
import random

def retry(max_retries=3, base_delay=1.0, backoff_factor=2.0, exceptions=(Exception,)):
    """
    重试装饰器，支持指数退避策略。
    
    Args:
        max_retries: 最大重试次数
        base_delay: 基础延迟时间（秒）
        backoff_factor: 退避倍数
        exceptions: 需要捕获并重试的异常类型
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last_exception = e
                    if attempt < max_retries:
                        delay = base_delay * (backoff_factor ** attempt)
                        jitter = random.uniform(0, delay * 0.1)
                        total_delay = delay + jitter
                        print(f"[Retry] {func.__name__} 第{attempt+1}次失败: {e}，"
                              f"{total_delay:.2f}s 后重试...")
                        time.sleep(total_delay)
                    else:
                        print(f"[Retry] {func.__name__} 已达最大重试次数 {max_retries}")
            raise last_exception
        return wrapper
    return decorator

# 模拟不稳定的网络请求
call_count = 0

@retry(max_retries=3, base_delay=0.1, exceptions=(ConnectionError,))
def unstable_api_call():
    global call_count
    call_count += 1
    if call_count < 3:
        raise ConnectionError(f"连接失败 (第{call_count}次)")
    return {"status": "ok"}

result = unstable_api_call()
print(f"最终结果: {result}")

3.9 实战三：权限校验装饰器

import functools

def require_role(*allowed_roles):
    """权限校验装饰器，限制函数只能被特定角色调用"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 从第一个参数或 kwargs 中获取 user 对象
            user = kwargs.get('user') or (args[0] if args else None)
            if user is None:
                raise ValueError("缺少 user 参数")

            user_role = getattr(user, 'role', None)
            if user_role not in allowed_roles:
                raise PermissionError(
                    f"用户角色 '{user_role}' 无权访问 {func.__name__}，"
                    f"需要: {allowed_roles}"
                )
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 模拟用户对象
class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

@require_role("admin", "editor")
def delete_article(user, article_id):
    return f"用户 {user.name} 删除了文章 {article_id}"

admin = User("Alice", "admin")
viewer = User("Bob", "viewer")

print(delete_article(admin, 42))  # 用户 Alice 删除了文章 42

try:
    delete_article(viewer, 42)
except PermissionError as e:
    print(f"权限错误: {e}")
    # 权限错误: 用户角色 'viewer' 无权访问 delete_article，需要: ('admin', 'editor')

---

四、高阶函数

高阶函数是指接受函数作为参数 或返回函数作为结果的函数。前面讲的闭包和装饰器都是高阶函数的应用。本节重点介绍 Python 内置的高阶函数。

4.1 map(function, iterable)

对可迭代对象的每个元素应用函数，返回一个惰性迭代器：

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

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

# 传入内置函数
strs = ["1", "2", "3"]
ints = list(map(int, strs))
print(ints)  # [1, 2, 3]

# 多个可迭代对象
a = [1, 2, 3]
b = [10, 20, 30]
sums = list(map(lambda x, y: x + y, a, b))
print(sums)  # [11, 22, 33]

4.2 filter(function, iterable)

筛选出使函数返回 True 的元素：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 筛选偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# 过滤空字符串
words = ["hello", "", "world", "", "python"]
non_empty = list(filter(None, words))  # None 作为函数时，过滤掉 falsy 值
print(non_empty)  # ['hello', 'world', 'python']

4.3 reduce(function, iterable)

对可迭代对象进行累积计算（需从 functools 导入）：

from functools import reduce

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

# 累乘
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120 (1*2*3*4*5)

# 带初始值
total = reduce(lambda x, y: x + y, numbers, 100)
print(total)  # 115 (100+1+2+3+4+5)

# 实际应用：展平嵌套列表
nested = [[1, 2], [3, 4], [5, 6]]
flat = reduce(lambda acc, lst: acc + lst, nested, [])
print(flat)  # [1, 2, 3, 4, 5, 6]

4.4 sorted(iterable, key=function)

根据自定义规则排序：

# 按字符串长度排序
words = ["python", "is", "a", "great", "language"]
by_length = sorted(words, key=len)
print(by_length)  # ['a', 'is', 'great', 'python', 'language']

# 按对象属性排序
users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35},
]
by_age = sorted(users, key=lambda u: u["age"])
print([u["name"] for u in by_age])  # ['Bob', 'Alice', 'Charlie']

# 多条件排序：先按年龄升序，再按姓名降序
from operator import itemgetter

records = [
    ("Alice", 30), ("Bob", 25), ("Charlie", 30), ("Diana", 25)
]
sorted_records = sorted(records, key=lambda r: (r[1], r[0]))
print(sorted_records)
# [('Bob', 25), ('Diana', 25), ('Alice', 30), ('Charlie', 30)]

4.5 functools.partial -- 偏函数

partial 可以固定函数的部分参数，生成一个新的函数：

from functools import partial

# 固定 base 参数
int_from_binary = partial(int, base=2)
int_from_hex = partial(int, base=16)

print(int_from_binary("1010"))  # 10
print(int_from_hex("ff"))      # 255

# 实际应用：简化回调函数
def log(level, message):
    print(f"[{level}] {message}")

info = partial(log, "INFO")
error = partial(log, "ERROR")

info("Server started")    # [INFO] Server started
error("Connection lost")  # [ERROR] Connection lost

4.6 operator 模块

operator 模块提供了函数形式的运算符，避免写 lambda：

from operator import add, mul, itemgetter, attrgetter
from functools import reduce

# 代替 lambda x, y: x + y
print(reduce(add, [1, 2, 3, 4, 5]))  # 15

# itemgetter 代替 lambda x: x["age"]
users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
]
by_age = sorted(users, key=itemgetter("age"))
print([u["name"] for u in by_age])  # ['Bob', 'Alice']

# attrgetter 用于对象属性
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

user_list = [User("Alice", 30), User("Bob", 25), User("Charlie", 35)]
by_age = sorted(user_list, key=attrgetter("age"))
print([u.name for u in by_age])  # ['Bob', 'Alice', 'Charlie']

# 多级属性排序
by_age_name = sorted(user_list, key=attrgetter("age", "name"))

4.7 组合使用：数据处理管道

高阶函数的真正威力在于组合使用，形成数据处理管道：

from functools import reduce

# 场景：处理订单数据
orders = [
    {"product": "laptop", "price": 5999, "quantity": 2},
    {"product": "mouse", "price": 99, "quantity": 5},
    {"product": "keyboard", "price": 299, "quantity": 3},
    {"product": "monitor", "price": 2499, "quantity": 1},
    {"product": "cable", "price": 29, "quantity": 10},
]

# 管道：筛选单价>100的 → 计算每个订单总额 → 求总计
total = reduce(
    lambda acc, x: acc + x,
    map(
        lambda order: order["price"] * order["quantity"],
        filter(
            lambda order: order["price"] > 100,
            orders
        )
    )
)
print(f"高价商品总额: {total}")  # 5999*2 + 299*3 + 2499*1 = 15394

# 等价的列表推导式写法（通常更 Pythonic）
total_v2 = sum(
    o["price"] * o["quantity"]
    for o in orders
    if o["price"] > 100
)
print(f"高价商品总额: {total_v2}")  # 15394

---

五、Lambda 与函数式编程范式

5.1 Lambda 的本质与边界

Lambda 是创建匿名函数的语法糖，只能包含一个表达式，表达式的结果即返回值：

# lambda 等价于简单的 def
square = lambda x: x ** 2
# 等价于：
def square(x):
    return x ** 2

# lambda 支持多个参数
add = lambda a, b: a + b
greet = lambda name, greeting="Hello": f"{greeting}, {name}!"

print(add(3, 5))              # 8
print(greet("Alice"))         # Hello, Alice!
print(greet("Bob", "Hi"))     # Hi, Bob!

Lambda 的限制：

• 只能包含一个表达式，不能包含语句（如 if/else 语句、for 循环、try/except）
• 不能有类型标注
• 没有名字，调试时堆栈显示为 <lambda>
• 不能包含赋值操作

# 条件表达式可以用（这是表达式，不是语句）
classify = lambda x: "positive" if x > 0 else "negative" if x < 0 else "zero"
print(classify(-5))  # negative

# 但复杂逻辑不应该用 lambda
# 反面教材：
process = lambda data: (
    sorted(
        filter(lambda x: x > 0,
               map(lambda x: x ** 2 - 10, data)),
        reverse=True
    )
)
# 可读性极差，应该使用具名函数

5.2 列表推导式 vs map+lambda

import timeit

numbers = list(range(100000))

# 方式1：列表推导式
t1 = timeit.timeit(
    '[x**2 for x in numbers]',
    globals={'numbers': numbers},
    number=100
)

# 方式2：map + lambda
t2 = timeit.timeit(
    'list(map(lambda x: x**2, numbers))',
    globals={'numbers': numbers},
    number=100
)

# 方式3：map + operator
from operator import pow
from functools import partial
square_op = partial(pow, b=2)
# 注意 operator.pow 接受两个参数，这里仅作示意

print(f"列表推导式: {t1:.4f}s")
print(f"map+lambda: {t2:.4f}s")

典型结果：

列表推导式: 1.0245s
map+lambda: 1.2890s

结论与选择建议：

场景	推荐方式	原因
简单映射	列表推导式	更 Pythonic，性能更好
简单过滤	列表推导式	[x for x in lst if cond] 更清晰
映射+过滤	列表推导式	单一表达式完成
传递给高阶 API	lambda 或具名函数	如 sorted(key=...), map(func, ...)
复杂逻辑	具名函数	可读性、可测试性
reduce 场景	lambda 可接受	推导式无法替代 reduce

Python 社区的共识：推导式是首选，lambda 用于传递简单函数给高阶函数，复杂逻辑始终使用具名函数。Guido van Rossum 本人曾多次表示后悔将 lambda 加入 Python。

---

六、面试高频题详解

Q1：手写一个带参数的装饰器，实现接口耗时统计

import functools
import time

def timing(precision=4, log_args=False):
    """
    带参数的耗时统计装饰器。
    
    Args:
        precision: 时间精度（小数位数）
        log_args: 是否记录函数参数
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            start = time.perf_counter()
            result = func(*args, **kwargs)
            elapsed = time.perf_counter() - start

            if log_args:
                print(f"[TIMING] {func.__name__}(args={args}, kwargs={kwargs}) "
                      f"耗时: {elapsed:.{precision}f}s")
            else:
                print(f"[TIMING] {func.__name__} 耗时: {elapsed:.{precision}f}s")
            return result
        return wrapper
    return decorator

@timing(precision=2, log_args=True)
def process_data(data):
    time.sleep(0.05)
    return sorted(data)

process_data([3, 1, 2])
# [TIMING] process_data(args=([3, 1, 2],), kwargs={}) 耗时: 0.05s

回答要点：

• 三层嵌套结构（参数层 → 装饰器层 → 包装层）
• 必须使用 functools.wraps
• 异常情况下也应该记录耗时（可在 try/finally 中实现）

Q2：闭包变量延迟绑定问题如何解决？

# 问题代码
def multiply():
    return [lambda x: i * x for i in range(4)]
# 所有 lambda 共享同一个 i，调用时 i=3，所以全是 300

# 方案1：默认参数立即绑定
def multiply_v1():
    return [lambda x, i=i: i * x for i in range(4)]

# 方案2：生成器逐个 yield
def multiply_v2():
    for i in range(4):
        yield lambda x: i * x

# 方案3：functools.partial 固定参数
from functools import partial
def multiply_v3():
    return [partial(lambda i, x: i * x, i) for i in range(4)]

# 验证
for version in [multiply_v1, multiply_v2, multiply_v3]:
    print([m(100) for m in version()])
# 全部输出: [0, 100, 200, 300]

回答要点：

• 根因是闭包捕获的是变量引用 而非值快照
• 推荐方案一（默认参数），最简洁直观

Q3：装饰器堆叠的执行顺序是怎样的？

答：装饰器堆叠遵循自下而上装饰，自上而下执行的规则。

@A
@B
@C
def func():
    pass

# 等价于: func = A(B(C(func)))
# 装饰顺序: 先 C，再 B，最后 A
# 调用 func() 时: 先进入 A 的 wrapper，再进入 B 的 wrapper，
#   再进入 C 的 wrapper，最后执行原始 func
# 返回时按相反顺序退出

类比洋葱模型：A 是最外层，C 是最内层。

Q4：functools.wraps 的作用是什么？不用会怎样？

答：functools.wraps 将被装饰函数的元信息（__name__、__doc__、__module__、__qualname__、__annotations__、__dict__）拷贝到 wrapper 函数上，并设置 __wrapped__ 属性指向原函数。

不使用的后果：

1. 函数名变成 wrapper，调试堆栈难以追踪
2. 文档字符串丢失，help() 和文档生成工具失效
3. 依赖函数名的框架会出问题（如 Flask 路由注册会因名称冲突报错）
4. inspect 模块无法获取原函数的签名信息

---

本章总结

本文从底层原理到生产实战，系统性地剖析了 Python 函数式编程的三大核心机制：

1. 函数是一等公民 ：Python 中函数是对象，可以赋值、传递、返回、存储。callable 协议和 __call__ 方法使得类实例也能像函数一样使用。

2. 闭包（Closure） ：内函数捕获外函数变量引用的机制。三个必要条件是函数嵌套、引用自由变量、返回内函数。核心陷阱是延迟绑定 -- 闭包捕获的是变量引用而非值快照，用默认参数或生成器解决。

3. 装饰器（Decorator） ：闭包最重要的应用，在不修改原函数的前提下增加功能。从无参→带参→类装饰器层层递进。始终使用 functools.wraps。装饰器堆叠遵循洋葱模型。

4. 高阶函数 ：map、filter、reduce、sorted 是内置的函数式编程工具。functools.partial 实现偏函数，operator 模块提供运算符的函数形式。

5. Lambda ：适用于传递简单逻辑给高阶函数。复杂逻辑应使用具名函数。列表推导式在大多数场景下比 map+lambda 更 Pythonic 且更快。

核心原则：闭包和装饰器是理解 Python 框架（Flask、FastAPI、Django）的钥匙。掌握它们不仅能写出更优雅的代码，更能看懂框架源码中大量使用的装饰器模式。

---

下一篇预告

第 03 篇：面向对象编程进阶 -- 从 SOLID 原则到 Python 特色 OOP

下一篇文章将深入 Python 面向对象编程的高级领域。你将了解：

• __new__ vs __init__ ：类的两阶段构造过程，以及 __new__ 如何实现单例模式
• MRO 与 C3 线性化：多重继承时 Python 如何确定方法查找顺序，钻石继承问题的解决
• 鸭子类型（Duck Typing）：Python 多态的核心哲学，"不要问它是什么，问它能做什么"
• SOLID 原则：如何在 Python 中践行五大面向对象设计原则
• 组合优于继承：继承滥用的反模式与 Mixin 模式的正确使用
• 魔法方法大全 ：__repr__、__eq__、__hash__、__getitem__ 等协议的完整解读

OOP 是构建复杂系统的基础，理解这些高级特性将帮助你设计出更健壮、更可维护的 Python 应用。

---

Python 后端开发技术博客专栏 | 作者：耿雨飞

本文为专栏第 02 篇，共 25 篇。完整目录请参阅《Python技术博客专栏大纲》。