编辑“︁Python 代码优化”︁

= Python代码优化 =

'''Python代码优化'''是指通过改进代码结构、算法选择或利用语言特性来提高程序执行效率、降低资源消耗的过程。本专题将系统讲解从基础技巧到高级策略的优化方法，适用于不同阶段的Python开发者。

== 核心优化原则 ==
优化需遵循两个基本原则：
# '''正确性优先'''：优化不得改变程序的预期行为
# '''权衡法则'''：在时间优化（速度）、空间优化（内存）和可读性之间取得平衡

使用[[w:Big_O_notation|大O符号]]分析复杂度是优化的理论基础：
<math>O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2)</math>

== 基础优化技巧 ==

=== 选择高效数据结构 ===
{| class="wikitable"
|+ 数据结构操作复杂度对比
! 操作 !! 列表(list) !! 集合(set) !! 字典(dict)
|-
| 查找元素 || O(n) || O(1) || O(1)
|-
| 插入元素 || O(1)/O(n) || O(1) || O(1)
|}

'''示例'''：成员检查优化
<syntaxhighlight lang="python">
# 低效写法（列表）
data = [i for i in range(10000)]
if 9999 in data:  # O(n)操作
    print("Found")

# 优化写法（集合）
data_set = set(data)
if 9999 in data_set:  # O(1)操作
    print("Found")
</syntaxhighlight>

=== 循环优化 ===
* 避免在循环内重复计算不变值
* 使用列表推导式代替显式循环
* 考虑使用内置函数(map/filter)

'''案例'''：计算平方数
<syntaxhighlight lang="python">
# 原始版本
result = []
for i in range(1000):
    result.append(i**2)  # 每次迭代都调用append方法

# 优化版本
result = [i**2 for i in range(1000)]  # 列表推导式更高效
</syntaxhighlight>

== 中级优化策略 ==

=== 字符串拼接 ===
字符串不可变特性导致频繁拼接效率低下：
<syntaxhighlight lang="python">
# 低效拼接（产生多个临时对象）
output = ""
for s in string_list:
    output += s

# 高效方法
output = "".join(string_list)
</syntaxhighlight>

=== 局部变量访问 ===
函数内局部变量比全局变量访问更快：
<syntaxhighlight lang="python">
# 较慢
global_var = 10
def calculate():
    return global_var * 2  # 全局变量查找较慢

# 更快
def calculate():
    local_var = 10
    return local_var * 2  # 局部变量快速访问
</syntaxhighlight>

== 高级优化技术 ==

=== 使用生成器 ===
生成器(generator)可显著减少内存使用：
<syntaxhighlight lang="python">
# 传统方法（消耗内存）
def get_numbers(n):
    return [i for i in range(n)]

# 生成器版本（惰性求值）
def generate_numbers(n):
    for i in range(n):
        yield i
</syntaxhighlight>

=== 利用内置函数 ===
Python内置函数用C实现，通常比纯Python代码更快：
<syntaxhighlight lang="python">
# 自定义求和
total = 0
for x in data:
    total += x

# 内置函数优化
total = sum(data)  # 快3-5倍
</syntaxhighlight>

=== 缓存与记忆化 ===
使用<code>functools.lru_cache</code>缓存函数结果：
<syntaxhighlight lang="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)
</syntaxhighlight>

== 性能分析工具 ==

=== 时间测量 ===
使用<code>timeit</code>模块精确测量代码执行时间：
<syntaxhighlight lang="python">
import timeit

setup = "from math import sqrt"
stmt = "def func(): return [sqrt(x) for x in range(100)]"
print(timeit.timeit(stmt, setup, number=10000))
</syntaxhighlight>

=== 性能剖析 ===
使用<code>cProfile</code>找出性能瓶颈：
<syntaxhighlight lang="bash">
python -m cProfile my_script.py
</syntaxhighlight>

== 编译器优化 ==

=== 使用PyPy ===
PyPy的JIT编译器可显著提升计算密集型任务速度：
<mermaid>
graph LR
    A[Python代码] --> B[CPython解释执行]
    A --> C[PyPy JIT编译执行]
    C --> D[通常快3-10倍]
</mermaid>

=== Cython扩展 ===
将关键代码用Cython重写可获得C语言级别性能：
<syntaxhighlight lang="python">
# cython_test.pyx
def calculate(int n):
    cdef int i, result = 0
    for i in range(n):
        result += i
    return result
</syntaxhighlight>

== 实际应用案例 ==

'''场景'''：处理大型CSV文件（>1GB）

'''优化方案'''：
1. 使用生成器逐行处理
2. 选择高效解析库（如<code>csv</code>模块）
3. 批处理代替单条处理
4. 多进程处理（CPU密集型）

<syntaxhighlight lang="python">
import csv
from multiprocessing import Pool

def process_row(row):
    # 处理单行数据
    return transformed_data

def process_file(filename):
    with open(filename) as f:
        reader = csv.reader(f)
        with Pool(4) as p:  # 4个进程
            results = p.map(process_row, reader)
    return results
</syntaxhighlight>

== 优化误区 ==
* '''过早优化'''：在未确定性能瓶颈前进行优化
* '''可读性牺牲'''：过度优化导致代码难以维护
* '''微观优化'''：忽略算法复杂度而专注指令级优化

== 总结 ==
Python代码优化是循序渐进的过程，应从以下维度考虑：
1. 算法复杂度分析
2. Python特定优化模式
3. 适当使用工具链
4. 平衡性能与可维护性

记住Donald Knuth的名言："过早优化是万恶之源"。应在正确性保证和明确性能需求后再进行针对性优化。

[[Category:编程语言]]
[[Category:Python]]
[[Category:Python 高级主题]]