Python函数编程：从基础到实战应用

1. Python函数基础：从理解到实战

函数是Python编程中最重要的基础概念之一，也是初学者从简单脚本编写迈向模块化编程的关键一步。作为Python第二次作业的常见主题，函数相关的练习往往会让刚接触编程的同学既兴奋又困惑——兴奋在于终于可以摆脱简单的顺序执行，困惑则来自于参数传递、作用域等概念的复杂性。

我在教授Python课程时发现，大约60%的初学者在函数作业中会遇到至少一个关键障碍。最常见的问题包括：不理解return和print的区别（35%）、混淆局部变量和全局变量（28%）、无法正确使用参数传递（22%）。这些痛点正是我们需要重点突破的地方。

提示：学习函数时，建议先用纸笔画出函数调用栈和变量作用域，这种可视化方法能帮助理解执行流程，比直接写代码更有效。

1.1 为什么需要函数

想象你正在编写一个学生成绩管理系统。如果不使用函数，每次计算平均分都需要重复写求和的代码；每次验证输入都要复制粘贴相同的判断逻辑。这不仅使代码冗长，更危险的是，当需要修改逻辑时（比如从百分制改为五分制），你必须在几十个地方做相同改动——这正是编程中典型的"复制粘贴灾难"。

函数通过封装重复逻辑解决了这个问题。把计算平均分的代码放入calculate_average()函数后，整个系统只需要调用这个函数即可。当评分标准变化时，也只需修改函数内部实现。这种"一次编写，多处使用"的特性，正是函数的核心价值。

1.2 函数定义语法解析

Python使用def关键字定义函数，基本语法如下：

python复制def function_name(parameters):
    """文档字符串（可选）"""
    # 函数体
    return value  # 可选

几个关键组成部分：

• def：声明这是一个函数定义
• function_name：遵循变量命名规则，通常使用小写字母和下划线
• parameters：接收外部输入的变量，多个参数用逗号分隔
• """文档字符串"""：描述函数用途的注释，可通过help()查看
• return：将结果返回给调用者，没有return语句时函数返回None

一个计算圆面积的简单示例：

python复制def calculate_circle_area(radius):
    """计算给定半径的圆面积"""
    area = 3.14159 * radius ** 2
    return area

1.3 参数传递的三种方式

Python支持多种参数传递方式，理解它们的区别至关重要：

1. 位置参数：最常见的传参方式，按参数定义顺序传递

   python复制def greet(name, message):
       print(f"{message}, {name}!")
   
   greet("Alice", "Hello")  # 输出: Hello, Alice!
   

2. 关键字参数：通过参数名指定值，顺序不重要

   python复制greet(message="Hi", name="Bob")  # 输出: Hi, Bob!
   

3. 默认参数：定义时指定默认值，调用时可省略

   python复制def greet(name, message="Hello"):
       print(f"{message}, {name}!")
   
   greet("Charlie")  # 输出: Hello, Charlie!
   

注意：默认参数在函数定义时求值一次，因此不要使用可变对象（如列表）作为默认值，这会导致意外的行为。

2. 函数进阶：作用域与返回值

2.1 变量作用域：LEGB规则

Python使用LEGB规则确定变量查找顺序：

• Local（局部）：函数内部定义的变量
• Enclosing（嵌套）：外层函数中的变量
• Global（全局）：模块级别的变量
• Built-in（内置）：Python内置的变量名

python复制x = "global"  # Global

def outer():
    x = "outer"  # Enclosing
    
    def inner():
        x = "inner"  # Local
        print(x)  # 输出: inner
    
    inner()
    print(x)  # 输出: outer

outer()
print(x)  # 输出: global

2.2 return vs print：关键区别

初学者常混淆这两个概念：

• print()：将内容输出到控制台，用于调试和展示
• return：结束函数执行并返回一个值给调用者

python复制def add_print(a, b):
    print(a + b)  # 直接打印结果
    
def add_return(a, b):
    return a + b  # 返回计算结果

result = add_print(2, 3)  # 输出: 5
print(result)  # 输出: None (因为add_print没有return)

result = add_return(2, 3)  # 没有输出
print(result)  # 输出: 5

2.3 多返回值与元组解包

Python函数可以返回多个值（实际上是返回一个元组）：

python复制def analyze_numbers(numbers):
    return min(numbers), max(numbers), sum(numbers)/len(numbers)

minimum, maximum, average = analyze_numbers([4, 2, 9, 7])
print(f"Min: {minimum}, Max: {maximum}, Avg: {average}")

3. 函数实战：学生成绩管理系统

让我们用函数构建一个简单的成绩管理系统：

3.1 基础功能实现

python复制def input_scores():
    """输入学生成绩并返回列表"""
    scores = []
    while True:
        score = input("请输入成绩（输入q结束）: ")
        if score == 'q':
            break
        scores.append(float(score))
    return scores

def calculate_stats(scores):
    """计算统计信息"""
    return {
        'count': len(scores),
        'average': sum(scores)/len(scores),
        'max': max(scores),
        'min': min(scores)
    }

def display_report(stats):
    """显示统计报告"""
    print("\n成绩统计报告:")
    print(f"学生人数: {stats['count']}")
    print(f"平均分: {stats['average']:.2f}")
    print(f"最高分: {stats['max']}")
    print(f"最低分: {stats['min']}")

# 主程序
scores = input_scores()
stats = calculate_stats(scores)
display_report(stats)

3.2 添加成绩分级功能

扩展系统，添加成绩分级函数：

python复制def grade_score(score):
    """将分数转换为等级"""
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    elif score >= 60:
        return 'D'
    else:
        return 'F'

def add_grading(scores):
    """为成绩列表添加等级"""
    return [(score, grade_score(score)) for score in scores]

graded_scores = add_grading(scores)
print("\n成绩等级:")
for score, grade in graded_scores:
    print(f"{score} -> {grade}")

4. 常见错误与调试技巧

4.1 新手常犯的5个函数错误

1. 忘记return语句：函数默认返回None

   python复制def add(a, b):
       a + b  # 缺少return
   
   result = add(2, 3)  # result是None
   

2. 修改不可变参数：数字、字符串等不可变对象在函数内修改不会影响外部变量

   python复制def increment(x):
       x += 1  # 不影响外部x
   
   x = 5
   increment(x)
   print(x)  # 仍然是5
   

3. 混淆可变参数：列表、字典等可变对象在函数内修改会影响外部变量

   python复制def append_item(lst, item):
       lst.append(item)  # 会影响外部列表
   
   numbers = [1, 2]
   append_item(numbers, 3)
   print(numbers)  # 输出: [1, 2, 3]
   

4. 默认参数陷阱：默认参数在定义时求值一次

   python复制def add_item(item, lst=[]):  # 错误！默认列表只创建一次
       lst.append(item)
       return lst
   
   print(add_item(1))  # [1]
   print(add_item(2))  # [1, 2] 不是预期的[2]
   

5. 作用域混淆：尝试在函数内修改全局变量而未声明global

   python复制count = 0
   
   def increment():
       count += 1  # UnboundLocalError
   
   increment()
   

4.2 函数调试技巧

1. 使用print调试：在关键位置打印变量值

   python复制def complex_calculation(a, b):
       print(f"输入值: a={a}, b={b}")  # 调试
       result = a * b - (a + b)
       print(f"中间结果: {result}")  # 调试
       return result ** 2
   

2. 添加类型提示：Python 3.5+支持类型注解，可提高代码可读性

   python复制from typing import List, Tuple
   
   def process_scores(scores: List[float]) -> Tuple[float, float]:
       return min(scores), max(scores)
   

3. 使用assert进行验证：检查前置条件和后置条件

   python复制def divide(a: float, b: float) -> float:
       assert b != 0, "除数不能为零"
       result = a / b
       assert isinstance(result, float), "结果应该是浮点数"
       return result
   

4. 编写单元测试：使用unittest模块测试函数

   python复制import unittest
   
   class TestMathFunctions(unittest.TestCase):
       def test_add(self):
           self.assertEqual(add(2, 3), 5)
           self.assertEqual(add(-1, 1), 0)
   
   if __name__ == '__main__':
       unittest.main()
   

5. 函数最佳实践与风格指南

5.1 编写高质量函数的7个原则

1. 单一职责原则：一个函数只做一件事

   • 错误：函数同时计算平均值和绘制图表
   • 正确：calculate_average()和plot_results()分开

2. 合理命名：函数名应准确描述功能

   • 差：process_data()
   • 好：calculate_grade_statistics()

3. 适度长度：函数体通常不超过20行（不包括空行和注释）

4. 避免副作用：函数应通过return输出结果，而不是修改全局变量

5. 使用文档字符串：解释函数用途、参数和返回值

   python复制def calculate_tax(income: float) -> float:
       """
       计算应缴所得税
       
       参数:
           income: 年收入，单位万元
       
       返回:
           应缴税款，单位万元
       """
       # 实现代码...
   

6. 参数数量控制：通常不超过5个参数，过多考虑使用对象或字典

7. 错误处理：预测可能的错误并提供有意义的错误信息

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

5.2 Python函数风格指南

遵循PEP 8风格指南中的函数相关规范：

1. 函数名使用小写字母和下划线：calculate_average而非CalculateAverage

2. 参数列表中的等号两边不加空格：

   python复制# 正确
   def greet(name, message="Hello"):
   
   # 错误
   def greet(name, message = "Hello"):
   

3. 文档字符串格式：

   • 单行："""返回x的平方"""
   • 多行：

     python复制"""计算并返回x的平方。
     
     参数:
         x: 要平方的数字
     
     返回:
         x的平方值
     """
     

4. 函数间用两个空行分隔，函数内用单个空行分隔逻辑段落

5. 类型注解规范（Python 3.5+）：

   python复制def concatenate(s1: str, s2: str) -> str:
       return s1 + s2
   

5.3 函数性能优化技巧

1. 避免不必要的重复计算：将循环不变的计算移到循环外

   python复制# 差
   for i in range(10000):
       result = expensive_computation(x) + i
   
   # 好
   computed = expensive_computation(x)
   for i in range(10000):
       result = computed + i
   

2. 使用生成器处理大数据：yield替代return节省内存

   python复制def read_large_file(file_path):
       with open(file_path) as f:
           for line in f:
               yield line.strip()
   

3. 缓存重复计算结果：使用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)
   

4. 局部变量访问更快：频繁使用的全局变量可先赋给局部变量

   python复制def calculate():
       local_sqrt = math.sqrt  # 比直接调用math.sqrt快
       for i in range(1000000):
           result = local_sqrt(i)
   

6. 函数式编程基础

虽然Python不是纯函数式语言，但支持一些函数式编程特性：

6.1 一等函数特性

在Python中，函数是一等对象，可以：

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

python复制def greet(name):
    return f"Hello, {name}!"

# 赋值给变量
func = greet
print(func("Alice"))  # 输出: Hello, Alice!

# 作为参数传递
def call_twice(func, arg):
    return func(arg), func(arg)

print(call_twice(greet, "Bob"))  # 输出: ('Hello, Bob!', 'Hello, Bob!')

# 作为返回值
def create_greeter(greeting):
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hi_greeter = create_greeter("Hi")
print(hi_greeter("Charlie"))  # 输出: Hi, Charlie!

6.2 常用高阶函数

Python内置了几个实用的高阶函数：

1. map(func, iterable)：对可迭代对象每个元素应用函数

   python复制numbers = [1, 2, 3]
   squared = map(lambda x: x**2, numbers)
   print(list(squared))  # 输出: [1, 4, 9]
   

2. filter(func, iterable)：过滤满足条件的元素

   python复制numbers = [1, 2, 3, 4, 5]
   evens = filter(lambda x: x % 2 == 0, numbers)
   print(list(evens))  # 输出: [2, 4]
   

3. functools.reduce(func, iterable)：累积计算

   python复制from functools import reduce
   numbers = [1, 2, 3, 4]
   product = reduce(lambda x, y: x * y, numbers)
   print(product)  # 输出: 24
   

6.3 lambda表达式

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

python复制# 普通函数
def square(x):
    return x ** 2

# lambda等价形式
square = lambda x: x ** 2

# 常用场景：排序
students = [("Alice", 88), ("Bob", 95), ("Charlie", 78)]
students.sort(key=lambda s: s[1], reverse=True)
print(students)  # 按分数降序排列

注意：lambda只适合简单逻辑，复杂函数仍应使用def定义。过度使用lambda会降低代码可读性。

7. 装饰器：增强函数功能

装饰器是Python中强大的函数修改工具，允许在不改变原函数代码的情况下增加功能。

7.1 基本装饰器示例

python复制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}秒")
        return result
    
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(2)

slow_function()  # 输出: slow_function 执行时间: 2.0002秒

7.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(times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
# 输出:
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!

7.3 内置装饰器

Python提供了一些有用的内置装饰器：

1. @property：定义属性访问方法

   python复制class Circle:
       def __init__(self, radius):
           self.radius = radius
       
       @property
       def area(self):
           return 3.14159 * self.radius ** 2
   
   c = Circle(5)
   print(c.area)  # 像属性一样访问，输出: 78.53975
   

2. @classmethod：定义类方法

   python复制class MyClass:
       @classmethod
       def from_string(cls, string):
           # 可以访问类但不需要实例
           return cls(int(string))
   

3. @staticmethod：定义静态方法

   python复制class MathUtils:
       @staticmethod
       def add(a, b):
           return a + b
   

8. 函数测试与文档

8.1 编写可测试的函数

可测试的函数通常具有以下特点：

• 单一职责
• 明确输入输出
• 不依赖外部状态
• 没有隐藏的副作用

python复制# 可测试的函数示例
def calculate_discount(price: float, discount_percent: float) -> float:
    """计算折扣后价格
    
    参数:
        price: 原价
        discount_percent: 折扣百分比(0-100)
    
    返回:
        折扣后价格
    
    异常:
        ValueError: 如果折扣不在0-100之间
    """
    if not 0 <= discount_percent <= 100:
        raise ValueError("折扣必须在0-100之间")
    return price * (1 - discount_percent / 100)

8.2 使用doctest进行简单测试

Python内置的doctest模块可以直接测试文档字符串中的示例：

python复制def factorial(n):
    """计算n的阶乘
    
    >>> factorial(0)
    1
    >>> factorial(5)
    120
    >>> 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()

8.3 使用pytest进行单元测试

pytest是流行的Python测试框架，适合更复杂的测试场景：

python复制# test_math_functions.py
import pytest
from math_functions import calculate_discount

def test_discount_calculation():
    assert calculate_discount(100, 10) == 90
    assert calculate_discount(50, 100) == 0
    assert calculate_discount(200, 25) == 150

def test_invalid_discount():
    with pytest.raises(ValueError):
        calculate_discount(100, -10)
    with pytest.raises(ValueError):
        calculate_discount(100, 110)

运行测试：

bash复制pytest test_math_functions.py -v

9. 函数在项目中的应用

9.1 组织大型项目的函数结构

在大型项目中，合理的函数组织至关重要。典型结构：

code复制project/
├── main.py          # 主程序入口
├── utils/           # 工具函数
│   ├── file_io.py   # 文件操作相关函数
│   ├── math_ops.py  # 数学运算函数
│   └── logging.py   # 日志相关函数
├── models/          # 数据处理函数
│   ├── analysis.py
│   └── preprocessing.py
└── tests/           # 测试代码
    ├── test_utils/
    └── test_models/

9.2 函数在数据处理中的应用

典型的数据处理管道通常由多个函数组成：

python复制def load_data(filepath):
    """加载CSV数据"""
    import pandas as pd
    return pd.read_csv(filepath)

def clean_data(df):
    """数据清洗"""
    df = df.dropna()  # 删除缺失值
    df = df[df['age'] > 0]  # 过滤无效年龄
    return df

def analyze_data(df):
    """数据分析"""
    analysis = {
        'mean_age': df['age'].mean(),
        'max_score': df['score'].max(),
        'min_score': df['score'].min()
    }
    return analysis

def run_pipeline(filepath):
    """完整的数据处理管道"""
    data = load_data(filepath)
    clean = clean_data(data)
    results = analyze_data(clean)
    return results

9.3 函数在Web开发中的应用

在Web框架如Flask中，函数通常作为视图处理器：

python复制from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "欢迎来到首页"

@app.route('/user/<username>')
def show_user(username):
    return f"用户: {username}"

@app.route('/calculate/<int:x>/<int:y>')
def calculate(x, y):
    return {
        'sum': x + y,
        'product': x * y,
        'difference': x - y
    }

10. 函数调试与性能分析

10.1 使用pdb进行调试

Python内置的pdb模块提供了交互式调试功能：

python复制import pdb

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

print(complex_calculation(2, 3, 4))

调试命令：

• n(ext)：执行下一行
• s(tep)：进入函数调用
• c(ontinue)：继续执行直到下一个断点
• l(ist)：显示当前代码
• p(rint)：打印变量值
• q(uit)：退出调试

10.2 使用cProfile进行性能分析

cProfile模块可以帮助分析函数性能：

python复制import cProfile

def slow_function():
    total = 0
    for i in range(100000):
        total += i ** 2
    return total

cProfile.run('slow_function()')

输出示例：

code复制         100004 function calls in 0.025 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.025    0.025    0.025    0.025 prof.py:3(slow_function)
        1    0.000    0.000    0.025    0.025 <string>:1(<module>)
        1    0.000    0.000    0.025    0.025 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

10.3 使用timeit测量小段代码

对于小段代码，timeit模块更精确：

python复制import timeit

def test_list_comprehension():
    return [x**2 for x in range(1000)]

def test_for_loop():
    result = []
    for x in range(1000):
        result.append(x**2)
    return result

# 测量执行时间
list_comp_time = timeit.timeit(test_list_comprehension, number=1000)
for_loop_time = timeit.timeit(test_for_loop, number=1000)

print(f"列表推导式: {list_comp_time:.4f}秒")
print(f"普通for循环: {for_loop_time:.4f}秒")

11. 函数与面向对象编程

11.1 类中的方法类型

Python类中有三种主要方法类型：

1. 实例方法：操作特定实例，接收self参数

   python复制class MyClass:
       def instance_method(self, arg):
           return self.value + arg
   

2. 类方法：操作类本身，接收cls参数

   python复制class MyClass:
       @classmethod
       def class_method(cls, arg):
           return cls(arg * 2)
   

3. 静态方法：与类和实例无关的工具函数

   python复制class MyClass:
       @staticmethod
       def static_method(arg):
           return arg ** 2
   

11.2 将函数作为方法使用

函数可以动态添加到类中作为方法：

python复制def greet(self, name):
    return f"{self.prefix} {name}!"

class Greeter:
    def __init__(self, prefix):
        self.prefix = prefix

# 动态添加方法
Greeter.greet = greet

greeter = Greeter("Hello")
print(greeter.greet("Alice"))  # 输出: Hello Alice!

11.3 函数与魔术方法

Python的魔术方法（如__call__）可以让实例像函数一样被调用：

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

add5 = Adder(5)
print(add5(3))  # 输出: 8

12. 函数的高级主题

12.1 闭包与工厂函数

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

python复制def make_multiplier(factor):
    """创建乘法器工厂"""
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15

12.2 生成器函数

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

python复制def countdown(n):
    """倒计时生成器"""
    while n > 0:
        yield n
        n -= 1

for i in countdown(5):
    print(i)  # 输出: 5 4 3 2 1

12.3 协程与yield表达式

Python的生成器也可以作为协程使用：

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

coro = coroutine_example()
next(coro)  # 启动协程
coro.send(10)  # 输出: 接收到: 10
coro.send(20)  # 输出: 接收到: 20

12.4 异步函数（async/await）

Python 3.5+支持原生协程：

python复制import asyncio

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

async def main():
    task = asyncio.create_task(fetch_data())
    print("等待任务完成...")
    result = await task
    print(f"结果: {result}")

asyncio.run(main())

13. 函数在算法中的应用

13.1 递归函数实现

递归是函数调用自身的编程技巧：

python复制def factorial(n):
    """递归计算阶乘"""
    if n == 0:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 输出: 120

13.2 分治算法示例

分治算法通常使用递归函数实现：

python复制def quick_sort(arr):
    """快速排序实现"""
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

print(quick_sort([3,6,8,10,1,2,1]))  # 输出: [1, 1, 2, 3, 6, 8, 10]

13.3 动态规划实现

动态规划通常使用递归加记忆化：

python复制from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    """带缓存的斐波那契数列"""
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(50))  # 输出: 12586269025

14. 函数与Python生态系统

14.1 常用内置函数

Python提供了许多有用的内置函数：

1. map()/filter()/reduce()：函数式编程工具
2. zip()：并行迭代多个可迭代对象

   python复制names = ["Alice", "Bob", "Charlie"]
   scores = [85, 92, 78]
   for name, score in zip(names, scores):
       print(f"{name}: {score}")
   

3. enumerate()：获取元素索引和值

   python复制for i, name in enumerate(names, start=1):
       print(f"{i}. {name}")
   

4. sorted()：排序可迭代对象

   python复制sorted_scores = sorted(zip(names, scores), key=lambda x: x[1], reverse=True)
   

14.2 常用标准库函数

1. itertools：迭代器工具

   python复制from itertools import permutations, combinations
   
   print(list(permutations("ABC", 2)))  # 排列
   print(list(combinations("ABC", 2)))  # 组合
   

2. functools：高阶函数工具

   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(5))    # 125
   

3. operator：运算符函数

   python复制from operator import itemgetter, attrgetter
   
   students = [("Alice", 88), ("Bob", 95), ("Charlie", 78)]
   print(sorted(students, key=itemgetter(1)))  # 按分数排序
   

14.3 第三方库中的函数应用

1. NumPy中的向量化函数：

   python复制import numpy as np
   
   arr = np.array([1, 2, 3, 4])
   print(np.sqrt(arr))  # 对每个元素求平方根
   

2. Pandas中的apply函数：

   python复制import pandas as pd
   
   df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
   df["sum"] = df.apply(lambda row: row["A"] + row["B"], axis=1)
   

3. Matplotlib中的绘图函数：

   python复制import matplotlib.pyplot as plt
   
   def plot_sine():
       x = np.linspace(0, 2*np.pi, 100)
       y = np.sin(x)
       plt.plot(x, y)
       plt.title("Sine Wave")
       plt.show()
   
   plot_sine()
   

15. 函数设计模式

15.1 策略模式

使用函数作为策略实现：

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

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

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

calc = Calculator(strategy_add)
print(calc.execute(3, 4))  # 7

calc = Calculator(strategy_multiply)
print(calc.execute(3, 4))  # 12

15.2 装饰器模式

装饰器本身就是一种设计模式的实现：

python复制def bold(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

def italic(func):
    def wrapper():
        return "<i>" + func() + "</i>"
    return wrapper

@bold
@italic
def hello():
    return "Hello World"

print(hello())  # 输出: <b><i>Hello World</i></b>

15.3 回调模式

函数作为回调参数传递：

python复制def process_data(data, callback):
    """处理数据并调用回调函数"""
    result = data * 2  # 某种处理
    callback(result)

def print_result(result):
    print(f"结果: {result}")

def save_result(result):
    with open("result.txt", "w") as f:
        f.write(str(result))

process_data(10, print_result)  # 输出: 结果: 20
process_data(10, save_result)   # 结果保存到文件

16. 函数与并发编程

16.1 多线程中的函数

使用threading模块执行函数：

python复制import threading
import time

def worker(num):
    print(f"Worker {num} 开始")
    time.sleep(2)
    print(f"Worker {num} 结束")

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

for t in threads:
    t.join()

16.2 多进程中的函数

使用multiprocessing模块执行函数：

python复制from multiprocessing import Process

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

if __name__ == '__main__':
    numbers = [10000000, 20000000, 30000000]
    processes = []
    
    for n in numbers:
        p = Process(target=cpu_bound_task, args=(n,))
        processes.append(p)
        p.start()