本期目标
- 掌握 lambda 匿名函数，写出简洁优雅的单行函数
- 理解
*args和 **kwargs ，让函数接受任意数量的参数 - 理解装饰器（Decorator） 的核心原理，学会“在不修改函数代码的情况下增强函数功能”
一、为什么需要学习函数的高级特性？
上期我们学会了如何定义和调用函数。本期我们经常面临更复杂的场景：
- 你需要给
sort() 函数传入一个临时的、只用一次的排序规则——专门为此定义一个“正式”函数太啰嗦了（这时候需要 lambda）。 - 你要写一个“万能”的日志函数，它要能接收任意数量的参数并打印出来（这时候需要
*args 或 **kwargs）。 - 你要给100个不同的函数都加上“运行时间监控”功能，如果挨个去修改这100个函数的内部代码，不仅工作量大，还容易改出 bug（这时候需要 装饰器）。
这三个高级特性，是让你从“能写代码”升级到“能写优雅代码”的关键一步。
二、匿名函数（Lambda）——用完即走的“一次性”函数
1. 什么是 lambda 函数？
Lambda 函数是 Python 中的匿名函数 ——它没有名字，用一行表达式就能完成简单的功能。语法极其简洁：
它与普通函数的区别：
### 2. 基本使用# 普通函数def add1(x, y): return x + y# Lambda 函数（赋值给变量，相当于有了名字）add2 = lambda x, y: x + yprint(add1(3, 5)) # 8print(add2(3, 5)) # 8# 甚至可以直接使用，不赋值print((lambda x, y: x * y)(4, 5)) # 20
3. 在排序（sorted）中作为 key 函数
这是 lambda 最经典的应用场景——自定义排序规则：
# 按元组的第二个元素排序pairs = [(1, 'apple'), (3, 'banana'), (2, 'cherry')]pairs.sort(key=lambda x: x[1]) # 按字母顺序（第二个元素）排序print(pairs) # [(1, 'apple'), (3, 'banana'), (2, 'cherry')]# 对字典列表按指定字段排序students = [ {'name': '张三', 'score': 85}, {'name': '李四', 'score': 92}, {'name': '王五', 'score': 78}]# 按成绩从高到低排序sorted_students = sorted(students, key=lambda s: s['score'], reverse=True)print(sorted_students) # [{'name': '李四', 'score': 92}, ...]
💡 小贴士：在AI中，lambda 常用于 map()、filter() 等函数式编程操作。比如对数据批量标准化：list(map(lambda x: x/255, pixel_values))。
4. 与 map() 和 filter() 配合使用
# map：对列表每个元素应用函数nums = [1, 2, 3, 4, 5]squared = list(map(lambda x: x ** 2, nums))print(squared) # [1, 4, 9, 16, 25]# filter：筛选符合条件的元素evens = list(filter(lambda x: x % 2 == 0, nums))print(evens) # [2, 4]
⚠️ 使用建议：lambda 表达式只适合写单行、简单的逻辑。如果逻辑复杂（比如包含循环、多条件判断），请用普通 def 函数，否则会严重影响代码可读性。
三、可变参数（*args 和 **kwargs）——让函数“海纳百川”
有时候，你不知道调用者会传入多少个参数。比如写一个求和函数，用户可能传2个数、5个数、甚至10个数。如果只定义固定的位置参数，根本不够用。
1. *args —— 接收任意数量的位置参数
*args 把传入的所有位置参数打包成一个元组（Tuple），名字 args 可以随便起，但 * 是必须的。
def sum_all(*args): """计算任意多个数的总和""" total = 0 for num in args: total += num return totalprint(sum_all(1, 2, 3)) # 6print(sum_all(10, 20, 30, 40)) # 100print(sum_all()) # 0（可以传0个）# 也可以和普通参数混用（普通参数必须放在 *args 前面）def greet(greeting, *names): for name in names: print(f"{greeting}，{name}！")greet("你好", "张三", "李四", "王五")# 输出：你好，张三！ / 你好，李四！ / 你好，王五！
2. **kwargs —— 接收任意数量的关键字参数
**kwargs 把传入的所有关键字参数（键值对）打包成一个字典（Dict）。
def print_config(**kwargs): """打印所有配置项""" for key, value in kwargs.items(): print(f"{key} = {value}")print_config(lr=0.001, batch_size=32, epochs=100, optimizer="Adam")# 输出：# lr = 0.001# batch_size = 32# epochs = 100# optimizer = Adam
3. 组合使用（普通参数 + *args + **kwargs）
def universal_func(name, *args, **kwargs): print(f"Name: {name}") print(f"Args (tuple): {args}") print(f"Kwargs (dict): {kwargs}")universal_func("AI_Model", 1, 2, 3, lr=0.01, dropout=0.5)# 输出：# Name: AI_Model# Args (tuple): (1, 2, 3)# Kwargs (dict): {'lr': 0.01, 'dropout': 0.5}
⚠️ 参数定义的顺序必须是：普通参数 → *args → **kwargs。
💡 小贴士：**kwargs 在AI框架中极其常见。比如 PyTorch 的模型定义中，__init__(self, **kwargs) 可以接收任意配置参数，非常灵活。
四、装饰器（Decorator）——“在不改动源码的前提下增强函数”
1. 什么是装饰器？为什么需要它？
试想一个场景：你写了一个 AI 训练函数 train_model()，运行得很好。但你想知道这个函数执行了多长时间。你会怎么做？
方案A：修改函数内部，在开头和结尾加时间戳——但如果有100个函数都要加呢？而且这违反了“开闭原则”（对扩展开放，对修改关闭）。
方案B：用装饰器——在不修改原函数代码的情况下，给函数“套上一层”增强逻辑。
装饰器本质上是一个接收函数、返回新函数的高阶函数。
2. 闭包铺垫——理解装饰器的前提
在理解装饰器之前，需要先了解“闭包（Closure）”——函数内部定义的函数，可以访问外部函数的变量：
def outer(msg): def inner(): print(f"消息：{msg}") # inner 可以访问 outer 的变量 msg return inner # 返回内部函数本身（不带括号）# 调用my_func = outer("Hello AI")my_func() # 输出：消息：Hello AI
3. 手写一个最简单的装饰器
def my_decorator(func): """这是一个装饰器：在函数执行前后打印日志""" def wrapper(): print(">>> 函数执行前 <<<") func() # 执行原函数 print(">>> 函数执行后 <<<") return wrapper# 使用装饰器（语法糖 @）@my_decoratordef say_hello(): print("Hello, AI World!")# 调用say_hello()# 输出：# >>> 函数执行前 <<<# Hello, AI World!# >>> 函数执行后 <<<
在上面代码中，@my_decorator 等价于执行了 say_hello = my_decorator(say_hello)。
4. 处理带参数的函数（万能装饰器模板）
被装饰的函数可能带参数，所以 wrapper 必须能接收任意参数（用 *args 和 **kwargs）：
def my_decorator(func): def wrapper(*args, **kwargs): # 接收任意参数 print(">>> 开始执行 <<<") result = func(*args, **kwargs) # 透传参数给原函数 print(">>> 执行结束 <<<") return result return wrapper@my_decoratordef add(a, b): return a + b@my_decoratordef greet(name): print(f"你好，{name}")print(add(3, 5)) # 正常计算并返回8，同时打印日志greet("张三") # 打印日志并执行
### 5. ⚠️ 保留原函数元信息（`functools.wraps`）装饰器会“替换”掉原函数，导致原函数的 __name__ 等属性丢失。用 @wraps 修复：
import functoolsdef my_decorator(func): @functools.wraps(func) # 保留原函数信息 def wrapper(*args, **kwargs): print("执行中...") return func(*args, **kwargs) return wrapper@my_decoratordef important_func(): """这是一个重要函数""" passprint(important_func.__name__) # important_func（如果没有 @wraps，会输出 wrapper）print(important_func.__doc__) # 这是一个重要函数
五、实战项目：执行时间统计装饰器（AI 训练必备）
在训练 AI 模型时，监控每个环节（数据加载、前向传播、反向传播、评估）的耗时至关重要。我们用装饰器来实现这个功能。
完整代码
import timeimport functoolsdef timer(func): """ 装饰器：统计函数执行时间 用法：在函数定义上方 @timer """ @functools.wraps(func) def wrapper(*args, **kwargs): start_time = time.time() # 记录开始时间 result = func(*args, **kwargs) # 执行原函数 end_time = time.time() # 记录结束时间 elapsed = end_time - start_time # 计算耗时 # 格式化输出（根据耗时选择合适的单位） if elapsed < 0.001: unit = "微秒" value = elapsed * 1_000_000 elif elapsed < 1: unit = "毫秒" value = elapsed * 1000 else: unit = "秒" value = elapsed print(f"⏱️ [{func.__name__}] 执行耗时：{value:.2f} {unit}") return result return wrapper# ========== 使用示例 ==========@timerdef slow_function(): """模拟一个耗时任务（如数据加载）""" time.sleep(1.2) # 模拟耗时1.2秒 return "数据加载完成"@timerdef fast_function(): """模拟一个快速计算（如简单加法）""" total = sum(range(1_000_000)) # 计算1到100万的和 return total@timerdef train_epoch(epoch_id, lr=0.001): """模拟AI训练一个Epoch""" time.sleep(0.5) # 模拟训练 print(f"Epoch {epoch_id} 完成，学习率 {lr}") return f"Loss_{epoch_id}"if __name__ == "__main__": print(slow_function()) print("-" * 30) print(fast_function()) print("-" * 30) train_epoch(10, lr=0.0005)
运行效果：
进阶扩展：带参数的装饰器
我们还可以让装饰器本身接收参数，比如指定是否输出详细日志：
def timer_with_log(enable_log=True): """带参数的装饰器工厂""" def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) elapsed = time.time() - start if enable_log: print(f"⏱️ {func.__name__} 耗时：{elapsed:.3f}s") return result return wrapper return decorator@timer_with_log(enable_log=True)def task_a(): time.sleep(0.2)@timer_with_log(enable_log=False) # 静默模式def task_b(): time.sleep(0.1)task_a() # 打印耗时task_b() # 不打印任何东西
六、动手练习
练习1：Lambda 练习
现有字典列表 students = [{"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}]，请用 sorted() 和 lambda 按名字（字母顺序）排序。
👆 点击查看参考答案students = [{"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}]sorted_students = sorted(students, key=lambda s: s["name"])print(sorted_students)# [{'name': '张三', 'score': 85}, {'name': '李四', 'score': 92}, {'name': '王五', 'score': 78}]
练习2：*args 练习
编写函数 concat_strings(separator, *args)，将 args 中的所有字符串用 separator 连接起来并返回。例如 concat_strings("-", "a", "b", "c") 返回 "a-b-c"。
👆 点击查看参考答案def concat_strings(separator, *args): return separator.join(args)print(concat_strings("-", "a", "b", "c")) # a-b-cprint(concat_strings(", ", "苹果", "香蕉")) # 苹果, 香蕉
练习3：**kwargs 练习
编写函数 update_config(**kwargs)，接收任意配置项，将其更新到一个全局字典 config 中，并打印更新后的完整配置。
👆 点击查看参考答案config = {"lr": 0.01, "batch": 32}def update_config(**kwargs): config.update(kwargs) print("当前配置：", config)update_config(lr=0.001, epochs=100)# 当前配置： {'lr': 0.001, 'batch': 32, 'epochs': 100}
练习4（综合挑战）：用装饰器实现缓存（Memoization）
在 AI 中，有些递归计算（如斐波那契）会重复计算大量子问题。请编写一个装饰器 @memoize，自动缓存函数的计算结果。当输入参数相同时，直接从缓存返回，不再重复计算。
提示：在 wrapper 内部维护一个字典 cache = {}，键为参数，值为计算结果。
👆 点击查看参考答案import functoolsdef memoize(func): 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 return wrapper@memoizedef fib(n): if n <= 1: return n return fib(n-1) + fib(n-2)# 测试print(fib(35)) # 速度极快（因为缓存了子结果，原本会有指数级计算）
本期小结
本期我们解锁了函数的三大高级技能：
下期预告：本期我们学习了函数的进阶用法。下期我们将进入新篇章——模块与包。学会如何将我们的函数工具库打包成独立的 .py 文件，并在其他项目中导入使用。同时，我们会学习 Python 内置的强大模块（math、random、datetime、os），并制作一个实用的“天气查询工具”。
装饰器是 Python 中最精妙的设计之一。反复练习，直至将其内化！ 🚀
