Python函数底层原理与高级应用全解析

1. Python函数基础：从底层理解代码复用机制

作为Python开发者，我经常看到新手在重复编写相同的代码逻辑。函数作为Python编程的核心构建块，其重要性怎么强调都不为过。记得我刚学Python时，曾在一个数据处理脚本中复制粘贴了20多次相同的计算逻辑，后来需求变更时，我不得不逐个修改这些重复代码——这种痛苦经历让我深刻理解了函数的价值。

函数本质上是一个可重用的代码单元，它接收输入（参数），执行特定任务，并返回结果。在Python中，函数是通过def关键字定义的，这个设计源于Python"明确优于隐晦"的哲学理念。当你调用函数时，Python解释器会创建一个新的命名空间（作用域），所有局部变量都存在于这个独立空间中，函数执行完毕后这个空间就会被回收。

2. 函数定义与调用的底层原理

2.1 函数定义语法解析

当我们写下这样的函数定义时：

python复制def calculate_area(width, height=1):
    """计算矩形面积"""
    return width * height

Python解释器会执行以下操作：

1. 将函数对象存储在内存中
2. 将函数名calculate_area绑定到该对象
3. 记录参数列表和默认值(height的默认值为1)
4. 将文档字符串存储在函数的__doc__属性中

有趣的是，def实际上是一个可执行语句。这意味着函数定义是在运行时执行的，这解释了为什么我们可以在条件语句中定义不同的函数：

python复制if condition:
    def func():
        return "版本A"
else:
    def func():
        return "版本B"

2.2 函数调用时的内存管理

每次函数调用时，Python都会：

1. 创建一个新的栈帧(stack frame)用于存储局部变量
2. 将参数值绑定到参数名
3. 执行函数体代码
4. 返回结果后销毁该栈帧

这个机制解释了为什么函数内部的变量不会影响外部同名变量——它们存在于不同的命名空间中。例如：

python复制x = 10  # 全局变量

def modify():
    x = 20  # 局部变量
    print("函数内:", x)

modify()  # 输出: 函数内: 20
print("函数外:", x)  # 输出: 函数外: 10

3. 参数传递的四种模式详解

3.1 位置参数的工作原理

位置参数是最基础的参数传递方式，Python内部使用一个元组来保存这些参数。当调用函数时，解释器会按照定义时的顺序将实参与形参一一对应：

python复制def power(base, exponent):
    return base ** exponent

power(2, 3)  # 8

这里，2被赋值给base，3被赋值给exponent。如果参数数量不匹配，Python会抛出TypeError。

3.2 关键字参数的优势与实现

关键字参数通过参数名显式指定值，这在参数较多或可选参数情况下特别有用：

python复制def create_user(name, age, email, is_admin=False):
    # 函数体...

create_user(name="Alice", age=25, email="alice@example.com")

Python内部会将关键字参数转换为字典形式处理。这种方式的优点在于：

• 代码可读性更强
• 参数顺序可以任意
• 与默认参数配合使用时更灵活

3.3 默认参数的陷阱与最佳实践

默认参数在函数定义时就被求值并存储，这可能导致一个常见陷阱：

python复制def append_to(element, target=[]):  # 危险！默认值在定义时就被创建
    target.append(element)
    return target

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2] 不是预期的[2]

安全做法是使用None作为默认值：

python复制def append_to(element, target=None):
    if target is None:
        target = []
    target.append(element)
    return target

3.4 可变参数的内部机制

*args和**kwargs是Python中处理可变参数的强大工具：

python复制def logger(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)

logger(1, 2, 3, name="Alice", age=25)

实际上：

• *args将多余的位置参数收集到元组中
• **kwargs将多余的关键字参数收集到字典中

这种机制使得函数可以接受任意数量和类型的参数，这在装饰器和继承等高级用法中特别有用。

4. 返回值与作用域的深入探讨

4.1 返回多个值的本质

Python函数可以"返回多个值"，这实际上是返回一个元组的语法糖：

python复制def get_coordinates():
    x = 10
    y = 20
    return x, y  # 等价于 return (x, y)

a, b = get_coordinates()  # 元组解包

4.2 作用域链与LEGB规则

Python使用LEGB规则查找变量：

1. Local - 局部作用域
2. Enclosing - 嵌套函数的非全局作用域
3. Global - 模块全局作用域
4. Built-in - 内置作用域

python复制x = "global"

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

outer()

4.3 闭包与nonlocal关键字

闭包是指能够访问其他函数作用域变量的函数：

python复制def counter():
    count = 0
    def increment():
        nonlocal count  # 声明count不是局部变量
        count += 1
        return count
    return increment

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

nonlocal关键字允许我们在嵌套函数中修改外部函数的变量，而不使用global。

5. 函数式编程特性

5.1 一等函数特性

在Python中，函数是一等对象，这意味着：

• 可以赋值给变量
• 可以作为参数传递
• 可以作为返回值
• 可以存储在数据结构中

python复制def square(x):
    return x * x

# 赋值给变量
func = square
print(func(5))  # 25

# 作为参数传递
def apply(func, value):
    return func(value)

print(apply(square, 6))  # 36

5.2 lambda表达式

lambda用于创建匿名函数，适合简单的单行函数：

python复制# 常规函数
def add(a, b):
    return a + b

# lambda等价形式
add = lambda a, b: a + b

lambda常用于排序等高阶函数：

python复制users = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 20}]
users.sort(key=lambda user: user["age"])

5.3 内置高阶函数

Python提供了几个有用的高阶函数：

python复制# map: 对可迭代对象应用函数
numbers = [1, 2, 3]
squared = list(map(lambda x: x**2, numbers))  # [1, 4, 9]

# filter: 过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2]

# reduce: 累积计算
from functools import reduce
product = reduce(lambda x, y: x * y, numbers)  # 6

6. 装饰器原理与应用

6.1 装饰器基础

装饰器本质上是一个接受函数作为参数并返回新函数的函数：

python复制def debug(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}()")
        return func(*args, **kwargs)
    return wrapper

@debug
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))
# 输出:
# 调用 greet()
# Hello, Alice

6.2 带参数的装饰器

装饰器也可以接受参数，这需要额外嵌套一层函数：

python复制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")

say_hello()
# 输出:
# Hello
# Hello
# Hello

6.3 类装饰器

装饰器也可以使用类实现：

python复制class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0
    
    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"调用次数: {self.calls}")
        return self.func(*args, **kwargs)

@CountCalls
def example():
    print("函数执行")

example()
example()
# 输出:
# 调用次数: 1
# 函数执行
# 调用次数: 2
# 函数执行

7. 性能优化与最佳实践

7.1 避免不必要的函数调用

在循环中调用函数会有额外开销：

python复制# 不推荐
for i in range(10000):
    result = calculate(i)

# 推荐: 如果可能，将循环移到函数内部
def batch_calculate():
    results = []
    for i in range(10000):
        results.append(calculate(i))
    return results

7.2 使用局部变量加速访问

局部变量访问比全局变量更快：

python复制import math

def slow_calc(values):
    result = []
    for v in values:
        result.append(math.sqrt(v))  # 每次都要查找math模块
    return result

def fast_calc(values):
    result = []
    sqrt = math.sqrt  # 局部变量缓存函数
    for v in values:
        result.append(sqrt(v))
    return result

7.3 函数签名与类型提示

Python 3.5+支持类型提示，可以提高代码可读性：

python复制from typing import List, Tuple

def process_data(data: List[str]) -> Tuple[int, float]:
    count = len(data)
    avg = sum(len(s) for s in data) / count if count else 0.0
    return count, avg

8. 常见问题与调试技巧

8.1 参数传递错误

常见错误包括参数顺序错误或缺少必需参数：

python复制def divide(a, b):
    return a / b

# 错误示例
divide(10)  # 缺少b参数
divide(b=5, a=10)  # 正确

8.2 可变默认参数问题

如前所述，默认参数在定义时求值，可能导致意外行为：

python复制def add_item(item, items=[]):  # 危险！
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] 不是预期的[2]

8.3 作用域混淆

新手常混淆局部变量和全局变量：

python复制x = 10

def modify():
    x += 1  # 错误！尝试修改全局变量
    print(x)

modify()  # UnboundLocalError

正确做法是使用global声明：

python复制x = 10

def modify():
    global x
    x += 1
    print(x)

modify()  # 11

8.4 装饰器导致函数元信息丢失

装饰器会覆盖原函数的元信息：

python复制def decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator
def greet(name):
    """问候函数"""
    return f"Hello, {name}"

print(greet.__name__)  # wrapper
print(greet.__doc__)   # None

解决方案是使用functools.wraps:

python复制from functools import wraps

def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator
def greet(name):
    """问候函数"""
    return f"Hello, {name}"

print(greet.__name__)  # greet
print(greet.__doc__)   # 问候函数

9. 实际项目中的应用案例

9.1 数据处理的函数式风格

python复制def process_data(data):
    # 数据清洗
    cleaned = filter(lambda x: x is not None, data)
    # 数据转换
    transformed = map(lambda x: x * 2 if isinstance(x, (int, float)) else x, cleaned)
    # 数据聚合
    result = reduce(lambda acc, x: acc + (x if isinstance(x, (int, float)) else 0), 
                   transformed, 0)
    return result

9.2 使用闭包实现状态保持

python复制def make_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            raise ValueError("余额不足")
        balance -= amount
        return balance
    
    def get_balance():
        return balance
    
    return {
        "deposit": deposit,
        "withdraw": withdraw,
        "get_balance": get_balance
    }

account = make_account(100)
account["deposit"](50)  # 150
account["withdraw"](30)  # 120

9.3 装饰器实现权限控制

python复制def requires_permission(permission):
    def decorator(func):
        @wraps(func)
        def wrapper(user, *args, **kwargs):
            if permission not in user.get("permissions", []):
                raise PermissionError("权限不足")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@requires_permission("admin")
def delete_user(user, user_id):
    # 删除用户逻辑
    return f"用户 {user_id} 已删除"

admin_user = {"name": "Admin", "permissions": ["admin"]}
normal_user = {"name": "User", "permissions": ["read"]}

print(delete_user(admin_user, 123))  # 正常工作
print(delete_user(normal_user, 123))  # 抛出PermissionError

10. 函数设计的最佳实践

10.1 单一职责原则

每个函数应该只做一件事，并且做好这件事：

python复制# 不推荐
def process_user_data(user):
    # 验证数据
    if not user.get("name"):
        return False
    # 保存到数据库
    db.save(user)
    # 发送欢迎邮件
    send_email(user["email"], "Welcome!")
    return True

# 推荐
def validate_user(user):
    return bool(user.get("name"))

def save_user(user):
    db.save(user)

def send_welcome_email(user):
    send_email(user["email"], "Welcome!")

def process_user_data(user):
    if not validate_user(user):
        return False
    save_user(user)
    send_welcome_email(user)
    return True

10.2 合理的参数设计

• 限制参数数量（通常不超过5个）
• 使用关键字参数提高可读性
• 将相关参数组合为对象或字典

python复制# 不推荐
def create_user(name, age, email, address, phone, is_admin=False, is_active=True):
    pass

# 推荐
def create_user(name, *, age=None, email=None, metadata=None):
    """
    name: 必需参数
    age, email: 可选关键字参数
    metadata: 其他信息的字典
    """
    pass

10.3 清晰的文档与类型提示

良好的文档应该包括：

• 函数目的
• 参数说明
• 返回值说明
• 可能抛出的异常
• 使用示例

python复制def calculate_tax(income: float, brackets: List[Tuple[float, float]]) -> float:
    """
    根据给定的税率档次计算应缴税款
    
    参数:
        income: 应纳税所得额
        brackets: 税率档次列表，每个元素为(起征点, 税率)
        
    返回:
        计算得出的税款
        
    示例:
        >>> calculate_tax(5000, [(0, 0.1), (3000, 0.2)])
        700.0  # 3000*0.1 + 2000*0.2
    """
    tax = 0.0
    previous_bracket = 0
    for bracket in sorted(brackets):
        threshold, rate = bracket
        if income <= previous_bracket:
            break
        taxable = min(income, threshold) - previous_bracket
        tax += taxable * rate
        previous_bracket = threshold
    return tax

11. 调试与性能分析技巧

11.1 使用pdb进行调试

Python内置调试器pdb可以单步执行函数：

python复制import pdb

def complex_calculation(a, b):
    pdb.set_trace()  # 设置断点
    result = a * b
    result += a ** 2
    result -= b ** 3
    return result

print(complex_calculation(2, 3))

调试命令：

• n(ext): 执行下一行
• c(ontinue): 继续执行直到下一个断点
• p(rint): 打印变量值
• l(ist): 显示当前代码位置
• q(uit): 退出调试

11.2 性能分析工具

使用cProfile分析函数性能：

python复制import cProfile

def slow_function():
    total = 0
    for i in range(10000):
        for j in range(10000):
            total += i * j
    return total

profiler = cProfile.Profile()
profiler.runcall(slow_function)
profiler.print_stats()

11.3 使用timeit测量执行时间

python复制from timeit import timeit

def test_func():
    return sum(range(1000000))

execution_time = timeit(test_func, number=10)
print(f"平均执行时间: {execution_time / 10:.4f}秒")

12. 函数的高级应用

12.1 生成器函数

使用yield关键字创建生成器函数：

python复制def fibonacci_sequence(limit):
    """生成斐波那契数列"""
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

for num in fibonacci_sequence(100):
    print(num)

生成器特点：

• 惰性求值，节省内存
• 可以表示无限序列
• 支持管道式数据处理

12.2 协程与yield表达式

Python协程是更一般的生成器，可以接收数据：

python复制def coroutine_example():
    print("协程启动")
    while True:
        received = yield
        print(f"接收到: {received}")

coro = coroutine_example()
next(coro)  # 启动协程
coro.send("数据1")
coro.send("数据2")

12.3 上下文管理器

使用函数实现上下文管理器：

python复制from contextlib import contextmanager

@contextmanager
def managed_resource(path):
    print("获取资源")
    resource = open(path, 'r')
    try:
        yield resource
    finally:
        print("释放资源")
        resource.close()

with managed_resource('data.txt') as f:
    print(f.read())

13. 函数与面向对象编程

13.1 类方法与静态方法

python复制class Calculator:
    @classmethod
    def add(cls, a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

print(Calculator.add(2, 3))  # 5
print(Calculator.multiply(2, 3))  # 6

区别：

• 类方法接收cls参数，可以访问类属性
• 静态方法不接收特殊参数，就像普通函数

13.2 可调用对象

通过实现__call__方法让实例可像函数一样调用：

python复制class Adder:
    def __init__(self, n):
        self.n = n
    
    def __call__(self, x):
        return self.n + x

add5 = Adder(5)
print(add5(10))  # 15

13.3 函数与方法的区别

方法是绑定到类的函数：

python复制class MyClass:
    def method(self):
        return "实例方法"

    @classmethod
    def class_method(cls):
        return "类方法"

    @staticmethod
    def static_method():
        return "静态方法"

# 函数绑定方式不同
obj = MyClass()
print(obj.method())  # 自动传入self
print(MyClass.class_method())  # 自动传入cls
print(MyClass.static_method())  # 不自动传参

14. 元编程与函数

14.1 动态创建函数

使用types.FunctionType动态创建函数：

python复制import types

def create_function(name, arg_names, code):
    # 编译代码
    bytecode = compile(code, "<string>", "exec")
    
    # 创建函数对象
    globals_dict = {}
    exec(bytecode, globals_dict)
    func_code = globals_dict[name]
    
    # 创建函数
    return types.FunctionType(func_code.__code__, globals(), name, 
                            tuple(arg_names.split(',')))

dynamic_func = create_function("dynamic_add", "a,b", "def dynamic_add(a,b): return a+b")
print(dynamic_func(2,3))  # 5

14.2 函数自省

Python函数是对象，可以检查其属性：

python复制def example(a, b=1):
    """示例函数"""
    return a + b

print(example.__name__)  # example
print(example.__doc__)  # 示例函数
print(example.__code__.co_varnames)  # ('a', 'b')
print(example.__defaults__)  # (1,)

14.3 修改函数行为

可以动态修改函数：

python复制def original():
    return "原始函数"

def decorator(func):
    def wrapper():
        return "装饰后的: " + func()
    return wrapper

original = decorator(original)
print(original())  # 装饰后的: 原始函数

15. 函数性能优化进阶

15.1 使用functools.lru_cache缓存结果

python复制from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(50))  # 非常快，因为有缓存

15.2 使用Cython加速关键函数

python复制# 保存为.pyx文件
def cython_fib(int n):
    cdef int a=0, b=1, i, temp
    for i in range(n):
        temp = a
        a = b
        b = temp + b
    return a

编译后可以显著提升性能。

15.3 避免不必要的属性查找

python复制# 不推荐
def slow_func(data):
    for item in data:
        process(item.attr1, item.attr2)

# 推荐
def fast_func(data):
    for item in data:
        attr1 = item.attr1
        attr2 = item.attr2
        process(attr1, attr2)

16. 函数测试与验证

16.1 单元测试示例

python复制import unittest

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

class TestDivide(unittest.TestCase):
    def test_divide_normal(self):
        self.assertEqual(divide(10, 2), 5)
    
    def test_divide_zero(self):
        with self.assertRaises(ValueError):
            divide(10, 0)

if __name__ == "__main__":
    unittest.main()

16.2 使用doctest测试文档字符串

python复制def factorial(n):
    """
    计算阶乘
    
    >>> factorial(5)
    120
    >>> factorial(0)
    1
    >>> factorial(-1)
    Traceback (most recent call last):
    ...
    ValueError: n必须是非负整数
    """
    if n < 0:
        raise ValueError("n必须是非负整数")
    return 1 if n == 0 else n * factorial(n-1)

if __name__ == "__main__":
    import doctest
    doctest.testmod()

16.3 使用pytest进行参数化测试

python复制import pytest

@pytest.mark.parametrize("a,b,expected", [
    (1, 1, 2),
    (2, 3, 5),
    (0, 0, 0),
])
def test_add(a, b, expected):
    assert add(a, b) == expected

17. 函数与并发编程

17.1 多线程中的函数

python复制import threading

def worker(num):
    print(f"工作线程 {num} 开始")
    # 执行任务...
    print(f"工作线程 {num} 结束")

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

17.2 多进程中的函数

python复制import multiprocessing

def cpu_bound_task(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(cpu_bound_task, range(10))
    print(results)

17.3 异步函数

python复制import asyncio

async def fetch_data(url):
    print(f"开始获取 {url}")
    await asyncio.sleep(2)  # 模拟IO操作
    print(f"完成获取 {url}")
    return f"{url} 的数据"

async def main():
    tasks = [
        fetch_data("url1"),
        fetch_data("url2"),
        fetch_data("url3")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

18. 函数式编程实践

18.1 不可变数据转换

python复制def process_data(data):
    # 不修改原始数据，返回新数据
    return [transform(item) for item in data if filter(item)]

18.2 高阶函数组合

python复制from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(3))    # 27

18.3 函数组合与管道

python复制def compose(*funcs):
    def composed(arg):
        for f in reversed(funcs):
            arg = f(arg)
        return arg
    return composed

# 创建组合函数
process = compose(str.upper, lambda s: s.strip(), str)

print(process("  hello  "))  # "HELLO"

19. 函数设计模式

19.1 策略模式

python复制def strategy_add(a, b):
    return a + b

def strategy_multiply(a, b):
    return a * b

class Calculator:
    def __init__(self, strategy=strategy_add):
        self.strategy = strategy
    
    def calculate(self, a, b):
        return self.strategy(a, b)

calc = Calculator()
print(calc.calculate(2, 3))  # 5

calc.strategy = strategy_multiply
print(calc.calculate(2, 3))  # 6

19.2 工厂模式

python复制def create_adder(n):
    def adder(x):
        return x + n
    return adder

add5 = create_adder(5)
add10 = create_adder(10)

print(add5(3))   # 8
print(add10(3))  # 13

19.3 观察者模式

python复制def create_observable():
    observers = []
    
    def subscribe(observer):
        observers.append(observer)
    
    def unsubscribe(observer):
        observers.remove(observer)
    
    def notify(message):
        for observer in observers:
            observer(message)
    
    return {
        "subscribe": subscribe,
        "unsubscribe": unsubscribe,
        "notify": notify
    }

observable = create_observable()

def logger(message):
    print(f"日志: {message}")

observable["subscribe"](logger)
observable["notify"]("事件发生")

20. 函数与模块化设计

20.1 模块化函数组织

良好的函数组织方式：

• 相关函数分组到模块中
• 每个模块有明确单一的责任
• 模块间通过函数接口交互

python复制# 文件: math_operations.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# 文件: main.py
from math_operations import add, subtract

print(add(2, 3))

20.2 包结构设计

对于大型项目，使用包组织函数：

code复制my_package/
    __init__.py
    utils/
        __init__.py
        math_utils.py
        string_utils.py
    models/
        __init__.py
        user.py
        product.py

20.3 接口设计原则

良好的函数接口应该：

• 简单易用
• 参数数量合理
• 有明确的输入输出
• 处理错误情况
• 有完整的文档

python复制def calculate_tax(income, tax_brackets):
    """
    计算所得税
    
    参数:
        income: 应纳税所得额(浮点数)
        tax_brackets: 税率档次列表，每个元素为(起征点, 税率)
        
    返回:
        计算得出的税款(浮点数)
        
    异常:
        ValueError: 如果income为负数或tax_brackets为空
    """
    if income < 0:
        raise ValueError("收入不能为负数")
    if not tax_brackets:
        raise ValueError("必须提供税率档次")
    
    # 计算逻辑...
    return tax_amount

21. 函数与异常处理

21.1 异常处理最佳实践

python复制def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("警告: 除数为零")
        return float('inf')  # 返回无穷大
    except TypeError:
        print("错误: 参数类型不正确")
        raise  # 重新抛出异常

21.2 自定义异常

python复制class InvalidInputError(Exception):
    """输入无效时抛出"""
    pass

def process_input(value):
    if not isinstance(value, (int, float)):
        raise InvalidInputError("必须是数字")
    if value < 0:
        raise InvalidInputError("必须是非负数")
    return value ** 2

21.3 上下文管理器处理资源

python复制def process_file(path):
    try:
        with open(path) as f:
            data = f.read()
            # 处理数据...
    except FileNotFoundError:
        print(f"文件 {path} 不存在")
    except IOError as e:
        print(f"读取文件时出错: {e}")
    else:
        print("处理成功")
    finally:
        print("清理工作...")

22. 函数与日志记录

22.1 基本日志记录

python复制import logging

logging.basicConfig(level=logging.INFO)

def critical_operation(data):
    logging.info("开始执行关键操作")
    try:
        result = perform_operation(data)
        logging.info("操作成功完成")
        return result
    except Exception as e:
        logging.error(f"操作失败: {e}")
        raise

22.2 函数执行时间日志

python复制import time
from functools import wraps

def log_execution_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        print(f"{func.__name__} 执行时间: {end_time - start_time:.4f}秒")
        return result
    return wrapper

@log_execution_time
def slow_function():
    time.sleep(1)

22.3 结构化日志

python复制import logging
import json

def setup_logging():
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.INFO)
    
    handler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    
    logger.addHandler(handler)
    return logger

logger = setup_logging()

def process_data(data):
    logger.info("开始处理数据", extra={"data_size": len(data)})
    # 处理逻辑...
    logger.info("数据处理完成")

23. 函数与配置管理

23.1 配置驱动的函数

python复制def create_greeting(name, config):
    greeting = config.get("greeting", "Hello")
    punctuation = config.get("punctuation", "!")
    return f"{greeting}, {name}{punctuation}"

config = {
    "greeting": "Hi",
    "punctuation": "!!!"
}

print(create_greeting("Alice", config))  # Hi, Alice!!!

23.2 函数工厂模式

python复制def create_processor(config):
    if config["type"] == "uppercase":
        def processor(text):
            return text.upper()
    elif config["type"] == "reverse":
        def processor(text):
            return text[::-1]
    else:
        def processor(text):
            return text
    
    return processor

processor = create_processor({"type": "uppercase"})
print(processor("hello"))  # HELLO

23.3 动态加载配置

python复制import json

def load_config(path):
    with open(path) as f:
        return json.load(f)

def configure_function(func, config):
    func.config = config
    return func

@configure_function
def process_data(data):
    if process_data.config.get("verbose"):
        print(f"处理数据: {data}")
    # 处理逻辑...

config = load_config("config.json")
process_data = configure_function(process_data, config)

24. 函数与数据验证

24.1 参数验证装饰器

python复制def validate_input(*validators):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i, (arg, validator) in enumerate(zip(args, validators)):
                if not validator(arg):
                    raise ValueError(f"参数 {i} 无效")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_input(lambda x: x > 0, lambda x: isinstance(x, str))
def process(positive_num, text):
    return text * positive_num

print(process(3, "Hi