Python 的函数是代码复用的核心，模块化编程是工程化开发的基础，而内置模块则是 Python 生态的 “工具箱”—— 三者结合能让代码更简洁、可维护、高效。本文将从函数编程实战、模块化编程实践、常用内置模块探索三个维度，通过实战案例讲解核心用法，帮助你构建高质量的 Python 代码。

一、函数编程实战：从基础到进阶

函数是封装可复用逻辑的最小单元，Python 的函数支持灵活的参数设计、高阶特性（如闭包、装饰器），是实现代码抽象的关键。

1. 函数基础：参数与返回值

Python 函数的参数类型包括位置参数、关键字参数、默认参数、可变参数，灵活运用可适应不同场景。

（1）核心参数类型实战

def calculate_score(
    name,  # 位置参数（必填）
    base_score=60,  # 默认参数（可选）
    *bonus,  # 可变位置参数（接收多个值，转为元组）
    **kwargs  # 可变关键字参数（接收多个键值对，转为字典）
):
    """
    计算学生最终成绩：基础分 + 各项加分 + 额外调整分
    """
    total = base_score + sum(bonus)
    # 处理额外调整分（如考勤分、作业分）
    for key, value in kwargs.items():
        total += value
    return {
        "name": name,
        "total_score": total,
        "details": f"基础分：{base_score}，加分：{sum(bonus)}，额外调整：{sum(kwargs.values())}"
    }

# 调用示例
result1 = calculate_score("张三", 70, 10, 5, attendance=3, homework=2)
result2 = calculate_score("李四", bonus=(8, 4), homework=5)  # 关键字传参

print(result1)
# 输出：{'name': '张三', 'total_score': 90, 'details': '基础分：70，加分：15，额外调整：5'}
print(result2)
# 输出：{'name': '李四', 'total_score': 77, 'details': '基础分：60，加分：12，额外调整：5'}

（2）关键注意点

• 默认参数的陷阱：默认参数在函数定义时初始化，若使用可变对象（如列表、字典），会导致多次调用共享同一对象，建议用None作为占位符。

2. 函数进阶：闭包与装饰器

（1）闭包：嵌套函数的变量捕获

闭包是内部函数引用外部函数变量的特殊结构，可实现 “数据封装” 和 “状态保留”。

（2）装饰器：函数的 “增强插件”

装饰器是 Python 的语法糖，用于在不修改原函数代码的前提下，为函数添加额外功能（如日志、计时、权限校验）。

实战 1：计时装饰器（统计函数执行时间）

import time

def timer_decorator(func):
    """装饰器：统计函数执行时间"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数 {func.__name__} 执行时间：{end_time - start_time:.4f} 秒")
        return result
    return wrapper

# 使用装饰器
@timer_decorator
def slow_function(n):
    """模拟耗时函数"""
    time.sleep(n)
    return f"等待了{n}秒"

slow_function(1)  # 输出：函数 slow_function 执行时间：1.0005 秒

实战 2：带参数的装饰器（日志级别控制）

def log_decorator(level="info"):
    """带参数的装饰器：按级别输出日志"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level.upper()}] 函数 {func.__name__} 开始执行")
            result = func(*args, **kwargs)
            print(f"[{level.upper()}] 函数 {func.__name__} 执行完成")
            return result
        return wrapper
    return decorator

# 使用带参数的装饰器
@log_decorator(level="warning")
def process_data(data):
    return f"处理了 {len(data)} 条数据"

process_data([1,2,3])
# 输出：
# [WARNING] 函数 process_data 开始执行
# [WARNING] 函数 process_data 执行完成

3. 生成器函数：节省内存的迭代器

生成器函数通过yield关键字返回迭代器，无需一次性加载所有数据，适合处理大数据集。

def generate_large_data(n):
    """生成器函数：逐个生成0~n-1的数字，节省内存"""
    for i in range(n):
        yield i  # 暂停执行，返回当前值，下次调用继续

# 实战：遍历1000万条数据（仅占用单个元素的内存）
data_generator = generate_large_data(10**7)
for _ in range(5):
    print(next(data_generator))  # 0,1,2,3,4