6.1 函数基础

6.1.1 函数定义与调用

函数定义语法：

def function_name(parameters):
    """文档字符串（可选）"""
    # 函数体
    return [expression]  # 可选

函数调用原理：

核心要点：

• 命名空间隔离：每次函数调用创建独立的命名空间，避免变量冲突
• 生命周期管理：函数执行完毕后命名空间销毁，释放资源
• 返回值机制：return语句返回结果，无return则隐式返回None

注意事项：

• 函数名应使用蛇形命名法（snake_case）且具有描述性
• 函数定义后需调用才能执行
• 避免函数过长（建议不超过50行）

6.1.2 函数组成要素

表6-1 函数核心组成要素

文档字符串使用建议：

• 使用三重引号编写多行文档
• 描述函数功能、参数和返回值
• 遵循PEP 257规范
• 可通过help(function_name)访问

6.1.3 简单函数示例

def greet(name):
    """返回个性化问候语
    
    Args:
        name (str): 用户名
        
    Returns:
        str: 问候字符串
    """
    return f"Hello, {name.capitalize()}!"

# 调用示例
print(greet("alice"))  # Hello, Alice!

函数设计原则：

• 单一职责原则：每个函数只完成一个明确任务
• 无副作用：理想情况下不修改外部状态
• 合理命名：函数名应准确反映功能
• 参数限制：参数不宜过多（建议≤5个）

6.2 参数传递

6.2.1 参数类型

四种参数类型：

参数组合顺序：

def func(positional, keyword=value, *args, **kwargs):
    pass

参数传递规则：

1. 位置参数必须在前，关键字参数在后
2. 默认参数必须位于位置参数之后
3. 可变位置参数*args收集多余位置参数
4. 可变关键字参数**kwargs收集多余关键字参数

6.2.2 参数传递示例

# 位置参数
defpower(base, exponent):
    return base ** exponent

# 关键字参数（提高可读性）
print(power(exponent=3, base=2))  # 8

# 默认参数（提供缺省值）
defconnect(host, port=3306, timeout=10):
    print(f"连接到 {host}:{port}, 超时:{timeout}s")

# 可变位置参数(*args)
defsum_numbers(*numbers):
    returnsum(numbers)

# 可变关键字参数(**kwargs)
defbuild_profile(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

默认参数陷阱：

# 错误示例：可变对象作为默认参数
def append_to(element, target=[]):
    target.append(element)
    return target

# 正确做法
def append_to(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target

6.2.3 参数解包

# 列表/元组解包为位置参数
args = [3, 4]
print(power(*args))  # 81

# 字典解包为关键字参数
kwargs = {"base": 2, "exponent": 5}
print(power(**kwargs))  # 32

解包应用场景：

• 传递已有数据结构作为参数
• 函数间参数透传
• 动态参数构造

6.3 返回值与作用域

6.3.1 返回值特性

多返回值实现：

def analyze_number(n):
    """返回数字的平方、立方和绝对值"""
    return n**2, n**3, abs(n)

# 元组解包接收多个返回值
square, cube, absolute = analyze_number(-3)

返回函数（高阶函数）：

def create_multiplier(factor):
    """创建乘法器函数"""
    def multiplier(x):
        return x * factor
    return multiplier

double = create_multiplier(2)
print(double(5))  # 10

返回值最佳实践：

• 返回一致的数据类型
• 避免返回None，考虑使用空对象模式
• 复杂返回值使用命名元组或数据类

6.3.2 变量作用域

LEGB规则：

作用域示例：

x = "global"

def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)  # local
    inner()
    print(x)  # enclosing

outer()
print(x)  # global

作用域管理：

• 使用global声明全局变量
• 使用nonlocal修改闭包变量
• 避免全局变量污染，优先使用参数传递

6.4 高阶函数

6.4.1 常用高阶函数

numbers = [1, 2, 3, 4]

# map: 应用函数到每个元素
squares = list(map(lambda x: x**2, numbers))

# filter: 过滤满足条件的元素
evens = list(filter(lambda x: x%2==0, numbers))

# reduce: 累积计算（需导入）
from functools import reduce
product = reduce(lambda x,y: x*y, numbers)

函数式编程优势：

• 代码简洁
• 无副作用
• 易于并行化
• 声明式风格

6.4.2 函数作为参数

def apply_operation(func, a, b):
    """应用指定操作到两个数"""
    return func(a, b)

# 使用匿名函数
result = apply_operation(lambda x,y: x+y, 3, 4)  # 7

# 使用预定义函数
import operator
result = apply_operation(operator.mul, 3, 4)  # 12

回调函数应用场景：

• 事件处理
• 排序自定义
• 算法策略模式
• 异步编程

6.5 闭包与装饰器

6.5.1 闭包实现

def counter():
    """闭包实现计数器"""
    count = 0
    def increment():
        nonlocal count  # 声明非局部变量
        count += 1
        return count
    return increment

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

闭包本质：

• 函数与其引用环境的组合
• 保持状态的生命周期
• 实现数据封装

6.5.2 装饰器应用

简单装饰器：

def timer(func):
    """测量函数执行时间"""
    import time
    defwrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__}执行耗时: {end-start:.4f}s")
        return result
    return wrapper

@timer  # 装饰器语法糖
deflong_running_task(n):
    returnsum(i*i for i inrange(n))

带参数装饰器：

def repeat(times):
    """重复执行函数"""
    defdecorator(func):
        defwrapper(*args, **kwargs):
            for _ inrange(times-1):
                func(*args, **kwargs)
            return func(*args, **kwargs)  # 返回最后一次结果
        return wrapper
    return decorator

@repeat(3)
defsay_hello():
    print("Hello!")

装饰器最佳实践：

1. 使用functools.wraps保留元信息
2. 避免装饰器副作用
3. 装饰器嵌套顺序从下往上
4. 复杂逻辑考虑类装饰器

6.6 函数式编程工具

6.6.1 functools模块

from functools import partial, lru_cache

# 偏函数：固定部分参数
square_root = partial(power, exponent=0.5)
print(square_root(9))  # 3.0

# 缓存装饰器：优化递归函数
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

functools实用工具：

• reduce：累积计算
• cmp_to_key：旧式比较函数转换
• total_ordering：自动生成比较方法
• singledispatch：函数重载

6.6.2 生成器函数

def fibonacci_sequence(limit):
    """生成斐波那契数列"""
    a, b = 0, 1
    while a < limit:
        yield a  # 产出值并暂停
        a, b = b, a + b

# 惰性求值，节省内存
print(list(fibonacci_sequence(100))) 
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

生成器优势：

• 惰性计算，节省内存
• 处理无限序列
• 实现协程和异步编程
• 管道式数据处理

6.7 应用举例

案例1：数据管道处理

def data_pipeline():
    """数据处理管道示例"""
    raw_data = ["10", "20", "30", "abc", "40"]
    
    # 处理步骤链
    steps = [
        lambda data: map(str.strip, data),      # 去空格
        lambda data: filter(str.isdigit, data), # 过滤数字
        lambda data: map(int, data),            # 转整数
        lambda data: map(lambda x: x*2, data),  # 数值加倍
        list                                    # 转为列表
    ]
    
    data = raw_data
    for step in steps:
        data = step(data)
        print(f"当前结果: {data}")
    
    return data

print("最终结果:", data_pipeline())

函数式管道优势：

• 每个步骤独立可测试
• 易于扩展和修改处理流程
• 清晰的数据转换过程
• 支持并行处理

案例2：权限检查装饰器

def permission_required(permission):
    """权限检查装饰器"""
    defdecorator(func):
        defwrapper(user, *args, **kwargs):
            # 检查权限位
            if user.get("permissions", 0) & permission != permission:
                raise PermissionError("权限不足")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

# 权限定义
READ = 0b0001
WRITE = 0b0010
DELETE = 0b0100
ADMIN = 0b1000

@permission_required(READ | WRITE)
defedit_document(user, document):
    print(f"{user['name']}正在编辑{document}")

# 使用示例
user = {"name": "Alice", "permissions": READ | WRITE}
edit_document(user, "重要文件")  # 正常执行

装饰器应用场景：

• 权限控制
• 日志记录
• 性能监控
• 输入验证
• 缓存实现

6.8 学习路线图

学习路径建议：

1. 掌握基础函数定义和调用
2. 理解参数传递机制
3. 学习作用域和闭包
4. 掌握装饰器原理和应用
5. 探索函数式编程范式
6. 学习生成器和协程
7. 深入元编程和描述符协议

6.9 Python函数编程要点总结

核心要点

1. 函数基础：

• 使用def定义函数，return返回值
• 函数是头等对象，可作为参数和返回值
• 文档字符串是良好实践

2. 参数处理：

• 位置参数、关键字参数、默认参数、可变参数
• 参数解包（*args, **kwargs）
• 避免可变对象作为默认参数

3. 作用域管理：

• 遵循LEGB查找规则
• 使用global和nonlocal谨慎修改作用域
• 闭包捕获环境状态

4. 高阶函数：

• 函数作为参数或返回值
• map
  /filter/reduce应用
• 函数组合和管道操作

5. 装饰器：

• 无参装饰器和带参装饰器
• 使用@functools.wraps保留元信息
• 装饰器堆叠顺序

6. 函数式工具：

• functools.partial
  创建偏函数
• functools.lru_cache
  实现缓存
• 生成器实现惰性求值

编程建议

• 单一职责原则：函数应专注单一功能
• 纯函数：相同输入产生相同输出，无副作用
• 合理命名：函数名应准确描述功能
• 参数限制：参数数量不宜过多（≤5个）
• 错误处理：使用异常而非返回错误代码
• 文档完整：公共函数必须包含文档字符串

进阶方向

1. 协程与异步：

• async
  /await语法
• 异步生成器
• 事件循环

2. 元编程：

• 装饰器进阶应用
• 函数签名检查（inspect模块）
• 动态函数创建

3. 函数式进阶：

• 柯里化（Currying）
• 函数组合（Compose）
• 单子（Monad）概念

4. 类型系统：

• 类型提示（Type Hints）
• 函数注解
• 静态类型检查

常见陷阱及规避

1. 可变默认参数：

   # 错误
   def add_item(item, items=[]):
       items.append(item)
       return items
   
   # 正确
   def add_item(item, items=None):
       if items is None:
           items = []
       items.append(item)
       return items
   

2. 闭包变量绑定：

   # 错误：所有函数共享i
   funcs = [lambda: i for i in range(3)]
   
   # 正确：创建闭包捕获当前值
   funcs = [lambda i=i: i for i in range(3)]
   

3. 装饰器元信息丢失：

   from functools import wraps
   
   def decorator(func):
       @wraps(func)  # 保留原始函数信息
       def wrapper(*args, **kwargs):
           return func(*args, **kwargs)
       return wrapper
   

4. 生成器状态耗尽：

   gen = (x for x in range(3))
   print(list(gen))  # [0, 1, 2]
   print(list(gen))  # [] 生成器已耗尽
   
   # 解决方案：重新创建生成器
   

掌握Python函数编程是成为Python开发必须要掌握的知识。通过理解函数基础、参数传递、作用域管理，再到高阶函数和装饰器应用，我们将能够编写更简洁、高效且可维护的代码。

阅读原文：原文链接