Python进阶-day18: 性能优化

目标

• 理解性能优化的意义，学会识别代码中的性能瓶颈。
• 掌握使用 timeit 模块测量代码执行时间的方法。
• 比较列表推导式与传统循环的性能差异。
• 通过优化排序算法案例，实践性能优化的具体方法。

概念

性能优化是指通过改进代码结构、算法或工具，减少程序的运行时间或资源消耗。以下是关键概念：

1. 性能优化的重要性： 用户体验：快速响应的程序提升用户满意度（如网页加载速度）。 资源节约：优化后的代码减少 CPU、内存等资源占用，降低成本。 可扩展性：高性能代码能处理更大规模的数据或并发请求。 场景示例：在 Web 开发中，优化后端 API 响应时间可显著提升用户体验；在机器学习中，优化算法可缩短模型训练时间。
2. timeit 模块： Python 内置模块，用于精确测量小段代码的执行时间。 优点：自动运行多次取平均值，减少随机误差。 用法：通过 timeit.timeit() 或命令行运行，适合比较不同实现的性能。
3. 列表推导式 vs 循环： 列表推导式（List Comprehension）是 Python 的高级语法，简洁且通常比循环快。 原因：推导式在 C 层实现，减少了 Python 解释器的开销。 适用场景：适合简单的列表生成操作，但复杂逻辑仍需循环。
4. 排序算法优化： 排序是常见任务，优化排序算法（如从冒泡排序到快速排序）可显著提升性能。 内置函数（如 sorted() 或 list.sort()）基于 Timsort 算法，性能优于手写算法。 优化策略：选择合适的算法、减少不必要的操作、利用内置方法。

案例：性能优化的实践

以下通过三个案例，展示性能优化的具体方法，并使用 timeit 测量效果。

案例 1：使用 timeit 测量代码性能

目标：比较两种生成平方数列表的方法（循环 vs 列表推导式）。

python

import timeit

# 方法 1：使用循环生成平方数列表
def square_loop(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result

# 方法 2：使用列表推导式生成平方数列表
def square_comprehension(n):
    return [i ** 2 for i in range(n)]

# 使用 timeit 测量性能
n = 10000
loop_time = timeit.timeit(lambda: square_loop(n), number=1000)
comp_time = timeit.timeit(lambda: square_comprehension(n), number=1000)

# 输出结果
print(f"循环耗时: {loop_time:.4f} 秒")
print(f"列表推导式耗时: {comp_time:.4f} 秒")
print(f"列表推导式比循环快: {(loop_time - comp_time) / loop_time * 100:.2f}%")

注释：

• timeit.timeit(lambda: square_loop(n), number=1000)：运行 1000 次 square_loop，返回总耗时。
• lambda 用于包装函数，防止直接调用影响测量。
• 结果通常显示列表推导式比循环快 30%-50%，因其在 C 层优化。

输出示例：

循环耗时: 0.2688 秒
列表推导式耗时: 0.2377 秒
列表推导式比循环快: 11.56%

优化意义：在处理大规模数据时，列表推导式的性能优势可显著减少运行时间，适用于数据预处理等场景。

案例 2：列表推导式与循环的性能差异

目标：优化一个过滤偶数的任务，比较循环和推导式的性能。

python

import timeit

# 方法 1：使用循环过滤偶数
def filter_even_loop(numbers):
    result = []
    for num in numbers:
        if num % 2 == 0:
            result.append(num)
    return result

# 方法 2：使用列表推导式过滤偶数
def filter_even_comprehension(numbers):
    return [num for num in numbers if num % 2 == 0]

# 准备测试数据
numbers = list(range(10000))

# 测量性能
loop_time = timeit.timeit(lambda: filter_even_loop(numbers), number=1000)
comp_time = timeit.timeit(lambda: filter_even_comprehension(numbers), number=1000)

# 输出结果
print(f"循环过滤耗时: {loop_time:.4f} 秒")
print(f"列表推导式过滤耗时: {comp_time:.4f} 秒")
print(f"列表推导式比循环快: {(loop_time - comp_time) / loop_time * 100:.2f}%")

注释：

• filter_even_loop 使用传统循环，逐个检查并添加偶数。
• filter_even_comprehension 用推导式实现相同逻辑，代码更简洁。
• timeit 运行 1000 次以确保结果稳定。

输出示例：

循环过滤耗时: 0.1764 秒
列表推导式过滤耗时: 0.1608 秒
列表推导式比循环快: 8.85%

优化意义：列表推导式不仅提升性能，还提高代码可读性，适合快速过滤或转换数据。

案例 3：优化排序算法

目标：比较冒泡排序、快速排序和内置 sorted() 的性能。

python

import timeit
import random

# 方法 1：冒泡排序
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

# 方法 2：快速排序
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)

# 方法 3：内置 sorted() 函数
def python_sorted(arr):
    return sorted(arr)

# 准备测试数据
random.seed(42)
data = [random.randint(1, 1000) for _ in range(1000)]

# 测量性能
bubble_time = timeit.timeit(lambda: bubble_sort(data.copy()), number=10)
quick_time = timeit.timeit(lambda: quick_sort(data.copy()), number=10)
sorted_time = timeit.timeit(lambda: python_sorted(data.copy()), number=10)

# 输出结果
print(f"冒泡排序耗时: {bubble_time:.4f} 秒")
print(f"快速排序耗时: {quick_time:.4f} 秒")
print(f"内置 sorted 耗时: {sorted_time:.4f} 秒")
print(f"内置 sorted 比冒泡排序快: {(bubble_time - sorted_time) / bubble_time * 100:.2f}%")

注释：

• bubble_sort：时间复杂度 O(n^2)，适合小数据集，但性能差。
• quick_sort：时间复杂度 O(n log n)，效率较高，但递归实现可能增加内存开销。
• python_sorted：基于 Timsort 算法，结合插入排序和归并排序，性能最佳。
• data.copy() 确保每次测试使用相同数据，避免排序修改原列表。

输出示例：

冒泡排序耗时: 0.1957 秒
快速排序耗时: 0.0049 秒
内置 sorted 耗时: 0.0004 秒
内置 sorted 比冒泡排序快: 99.82%

优化意义：

• 冒泡排序在处理 1000 元素时已明显慢于快速排序和内置 sorted()。
• 内置 sorted() 利用 C 语言实现和 Timsort 算法，性能远超手写算法。
• 在实际开发中，优先使用内置函数，除非有特殊需求。

• 性能优化的重要性：通过案例可见，优化后的代码（如列表推导式、快速排序、内置函数）可将运行时间缩短数倍甚至数百倍。这在大数据处理、实时应用中至关重要。
• 关键方法：
• 使用 timeit 精确测量性能，找到 瓶颈。
• 优先选择列表推导式替代简单循环。
• 利用内置函数（如 sorted()）替代手写算法。
• 实践建议：
• 编写代码时，先确保功能正确，再针对性能瓶颈优化。
• 对于复杂任务，结合算法优化和工具（如 NumPy、Cython）进一步提升性能。

通过以上案例，开发者可以掌握性能优化的核心技能，并在实际项目中应用这些方法提升代码效率。