第二十二篇：返回函数与闭包——函数式编程的高级技法
前言
返回函数和**闭包（Closure）**是 Python 中高级编程的核心概念。本文深入讲解如何从函数返回函数、闭包的原理与作用域机制，以及在实际开发中的常见应用场景。
返回函数
基本用法
def create_greeting(language):
"""根据语言返回不同的问候函数"""
if language == "zh":
def greet_zh(name):
return f"你好，{name}！"
return greet_zh
elif language == "en":
def greet_en(name):
return f"Hello, {name}!"
return greet_en
else:
raise ValueError(f"不支持的语言：{language}")
# 获取特定的函数
greet_chinese = create_greeting("zh")
greet_english = create_greeting("en")
print(greet_chinese("小明")) # 你好，小明！
print(greet_english("Alice")) # Hello, Alice!
工厂模式
def make_calculator(operation):
"""数学计算器工厂"""
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
operations = {
"+": add,
"-": subtract,
"*": multiply,
}
if operation in operations:
return operations[operation]
else:
raise ValueError(f"不支持的操作：{operation}")
add_fn = make_calculator("+")
sub_fn = make_calculator("-")
print(add_fn(10, 5)) # 15
print(sub_fn(10, 5)) # 5
延迟计算
def delayed_computation(func, args):
"""返回一个延迟计算的函数"""
def compute():
return func(*args)
return compute
def expensive_operation(x, y):
"""模拟昂贵的计算"""
import time
time.sleep(0.1) # 模拟耗时操作
return x ** y
# 不立即执行，而是存储函数引用
job = delayed_computation(expensive_operation, (2, 10))
# 稍后真正执行时才开始计算
print(job()) # 1024 — 此时才触发耗时操作
闭包（Closure）
什么是闭包？
闭包 = 函数 + 对其外部作用域的引用。当一个内部函数捕获了外层函数的变量，就形成了闭包。
def outer_function(message):
"""外层函数捕获 message 变量"""
def inner_function():
# inner_function 引用了外层变量 message
return f"{message}" ← 这里形成闭包
return inner_function
# 调用外层函数获取内层函数
say_hello = outer_function("你好")
print(say_hello()) # 你好 — 即使外层函数已结束运行
say_goodbye = outer_function("再见")
print(say_goodbye()) # 再见
关键特征：
- 内部函数引用了外部函数的局部变量
- 即使外部函数返回并销毁，其局部变量仍被保留
- 每个闭包实例都有自己独立的变量副本
验证闭包的存在
def create_counter(start):
counter = [start] # 列表可变，支持后续修改
def counter_func():
counter[0] += 1
return counter[0]
return counter_func
counter1 = create_counter(0)
counter2 = create_counter(100)
print(counter1()) # 1
print(counter1()) # 2
print(counter2()) # 101
print(counter2()) # 102
# 注意：counter1 和 counter2 各自拥有独立的 closure 空间
closure 属性
def outer(x, y):
z = x + y
def inner():
print(x, y, z) # 引用了 x, y, z
return inner
fn = outer(10, 20)
print(fn.__closure__)
# (<cell at 0x...: int object at 0x...>, <cell at 0x...>, <cell at 0x...>)
# 显示了三个被捕获的变量
实战应用场景
场景一：数据缓存/记忆化
from functools import lru_cache
@lru_cache(maxsize=None)
def fibonacci(n):
"""使用装饰器实现记忆化斐波那契"""
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(50)) # 瞬间输出，因为结果被缓存了
手动实现闭包缓存：
def memoize(func):
"""自定义记忆化装饰器"""
cache = {}
def wrapper(*args):
if args not in cache:
cache[args] = func(*args)
return cache[args]
wrapper.cache = cache # 可访问缓存内容
wrapper.clear_cache = lambda: cache.clear()
return wrapper
@memoize
def expensive_function(x):
total = sum(range(x * 1000000))
return total
print(expensive_function(5)) # 第一次：慢
print(expensive_function(5)) # 第二次：瞬间！（命中缓存）
expensive_function.clear_cache() # 清除缓存
场景二：配置模板系统
def create_form_renderer(template_config):
"""根据配置动态生成渲染函数"""
fields = template_config.get("fields", [])
labels = template_config.get("labels", {})
def render_form(data):
html_parts = ["<form>"]
for field in fields:
label = labels.get(field, field)
value = data.get(field, "")
html_parts.append(f'<div class="field">')
html_parts.append(f'<label>{label}</label>')
html_parts.append(f'<input type="text" name="{field}" value="{value}">')
html_parts.append("</div>")
html_parts.append("</form>")
return "".join(html_parts)
return render_form
config = {
"fields": ["username", "email", "password"],
"labels": {"username": "用户名", "email": "邮箱", "password": "密码"},
}
renderer = create_form_renderer(config)
data = {"username": "小明", "email": "xm@test.com"}
html = renderer(data)
print(html)
场景三：日志级别装饰器
import functools
import datetime
def log_level(level):
"""基于闭包的日志级别装饰器"""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] [{level.upper()}] 调用 {func.__name__}")
result = func(*args, **kwargs)
if level == "ERROR":
print(f"[{timestamp}] [{level.upper()}] {func.__name__} 异常")
return result
return wrapper
return decorator
@log_level("INFO")
def process_data(data):
print(f"处理 {len(data)} 条数据")
return len(data)
@log_level("DEBUG")
def calculate(a, b):
return a + b
process_data([1, 2, 3])
# [2024-01-01 12:00:00] [INFO] 调用 process_data
# 处理 3 条数据
场景四：状态机
def create_state_machine(states, transitions):
"""有限状态机构建器"""
current_state = [list(states)[0]] # 初始状态
def transition(to_state):
key = (current_state[0], to_state)
if key in transitions:
result = transitions[key](current_state[0])
if callable(result):
result() # 如果结果是函数则执行
current_state[0] = to_state
print(f"状态：{to_state}")
else:
print(f"无法从 {current_state[0]} 转换到 {to_state}")
return current_state[0]
def get_state():
return current_state[0]
return transition, get_state
# 定义转移关系
transitions = {
("idle", "click"): lambda: None,
("clicking", "release"): lambda: print("触发"),
}
transition, get_state = create_state_machine({"idle", "clicking", "triggered"}, transitions)
transition("click") # idle → clicking
print(get_state()) # clicking
transition("release") # 触发
常见问题与陷阱
问题一：循环变量捕获
# ❌ 错误：所有函数捕获相同的 i（最终值 4）
funcs = []
for i in range(5):
funcs.append(lambda: i)
for f in funcs:
print(f())
# 全部输出 4
# ✅ 修复方案：默认参数在定义时求值
funcs = []
for i in range(5):
funcs.append(lambda x=i: x)
for f in funcs:
print(f())
# 0 1 2 3 4 — 正确
问题二：可变默认参数的副作用
# ⚠️ 闭包共享同一个可变对象
def make_accumulator(initial=[]):
def accumulator(value):
initial.append(value)
return sum(initial)
return accumulator
acc1 = make_accumulator([]) # 每次都传入新列表
acc2 = make_accumulator([]) # 但这里也可能意外共享
print(acc1(1)) # 1
print(acc1(2)) # 3
print(acc2(1)) # 1 — 不受 acc1 影响
问题三：闭包内存泄漏
# ⚠️ 大量闭包可能占用过多内存
class LargeDataProcessor:
def __init__(self, large_dataset):
self.dataset = large_dataset # 大数据集
# 如果每次创建闭包都捕获 self.dataset
def process_chunk(chunk_id):
# chunk_id 很小，但 dataset 很大
return self.dataset[chunk_id * 100:(chunk_id + 1) * 100]
return process_chunk # 闭包引用了整个数据集
性能对比
闭包 vs 类实例
# 闭包方式
def create_counter_v1(start=0):
count = [start]
def increment():
count[0] += 1
return count[0]
return increment
counter1 = create_counter_v1()
print(counter1()) # 1
# 类方式
class CounterV2:
def __init__(self, start=0):
self.count = start
def increment(self):
self.count += 1
return self.count
counter2 = CounterV2()
print(counter2.increment()) # 1
| 特性 | 闭包 | 类 |
|---|---|---|
| 代码简洁度 | ✅ 更短 | ❌ 较冗长 |
| 可读性 | ⚠️ 简单逻辑清晰，复杂则难 | ✅ 结构明确 |
| 封装性 | ✅ 隐藏中间状态 | ✅ 暴露接口 |
| 扩展性 | ❌ 只能增加功能不能修改行为 | ✅ 可继承和多态 |
| 调试难度 | ❌ 闭包作用域深 | ✅ 实例变量易查 |
总结
本文讲解了返回函数与闭包的核心知识：
- 返回函数 — 从函数返回其他函数作为第一类公民
- 工厂模式 — 根据不同条件返回不同行为的函数
- 闭包原理 — 内部函数引用外部变量，形成持久化捕获
- closure — 查看闭包中捕获的变量
- 实战应用 — 缓存装饰器、表单渲染器、日志级别、状态机
- 常见陷阱 — 循环变量捕获、可变对象共享、内存泄漏
- 性能对比 — 闭包适合轻量级封装，复杂逻辑用类
下一篇文章将深入讲解装饰器与偏函数。
本文是 Python 教程系列的第二十二篇。