6.1 函数基础

6.1.1 函数定义与调用

函数定义语法：

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

函数调用原理：

6.1.2 函数组成要素

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

6.1.3 简单函数示例

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

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

6.2 参数传递

6.2.1 参数类型

四种参数类型：

参数组合顺序：

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

6.2.2 参数传递示例

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

# 关键字参数
print(power(exponent=3, base=2))  # 8

# 默认参数
def connect(host, port=3306, timeout=10):
    print(f"连接到 {host}:{port}, 超时:{timeout}s")

# 可变位置参数(*args)
def sum_numbers(*numbers):
    return sum(numbers)

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

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

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

6.4 高阶函数

6.4.1 常用高阶函数

map/filter/reduce：

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

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
    def wrapper(*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
def long_running_task(n):
    return sum(i*i for i in range(n))

带参数装饰器：

def repeat(times):
    """重复执行函数"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

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)

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"]
    
    # 处理步骤
    processed = (
        map(str.strip, raw_data),          # 去空格
        filter(str.isdigit, _),           # 过滤数字
        map(int, _),                      # 转整数
        map(lambda x: x*2, _),            # 数值加倍
        list                              # 转为列表
    )
    
    for step in processed:
        print(f"当前步骤: {step.__name__ if hasattr(step, '__name__') else str(step)}")
        data = step(data) if 'data' in locals() else step
        print(f"处理结果: {data}")
    
    return data

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

案例2：权限检查装饰器

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

# 权限定义
READ = 0b001
WRITE = 0b010
ADMIN = 0b100

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

# 使用示例
user = {"name": "Alice", "permissions": 0b011}
try:
    edit_document(user, "重要文件")
except PermissionError as e:
    print(e)

6.8 学习路线图

6.9 学习总结

1. 核心要点：
2. 理解函数定义与调用机制
3. 掌握各种参数传递方式
4. 熟练使用装饰器模式
5. 了解函数式编程思想
6. 实践建议：
7. 函数保持单一职责原则
8. 合理使用默认参数提高可用性
9. 为公共函数添加文档字符串
10. 使用装饰器分离横切关注点
11. 进阶方向：
12. 协程与异步函数
13. 函数签名检查(inspect模块)
14. 描述符协议实现
15. 元类编程
16. 常见陷阱：
17. 可变默认参数问题
18. 闭包变量捕获时机
19. 装饰器堆叠顺序
20. 名称空间污染

持续更新Python编程学习日志与技巧，敬请关注！

#编程# #python# #在头条记录我的2025#