Python 代码优化是一个涉及性能、可读性和资源管理的综合课题。以下从 实战角度 分享常见优化技巧和思路，配合代码示例说明：
一、基础优化策略
1. 避免重复计算
python
# 未优化：重复计算 len(my_list)
for i in range(len(my_list)):
if my_list[i] == some_value and i < len(my_list) - 1:
...
# 优化后：预先计算长度
n = len(my_list)
for i in range(n):
if my_list[i] == some_value and i < n - 1:
...
2. 选择高效数据结构
o 查找操作：用集合（set）或字典（dict）替代列表（O(1) vs O(n)）
python
# 未优化：列表查找
if x in my_list: # O(n)
...
# 优化后：集合查找
my_set = set(my_list)
if x in my_set: # O(1)
...
3. 利用内置函数与库
o 优先使用 map()、filter()、itertools 等内置工具（底层为 C 实现）
python
# 未优化：手动循环
result = []
for num in numbers:
result.append(num * 2)
# 优化后：列表推导式 + 内置函数
result = list(map(lambda x: x * 2, numbers))
二、算法优化
1. 减少时间复杂度
python
# 未优化：双重循环 O(n^2)
for a in array1:
for b in array2:
if a == b:
print(a)
# 优化后：利用集合 O(n)
set2 = set(array2)
for a in array1:
if a in set2:
print(a)
2. 动态规划代替暴力递归
python
# 未优化：递归计算斐波那契（指数复杂度）
def fib(n):
return n if n <= 1 else fib(n-1) + fib(n-2)
# 优化后：动态规划 O(n)
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
三、内存管理
1. 使用生成器（Generator）
python
# 未优化：一次性生成全部数据
def read_large_file(file):
return [line for line in file] # 可能内存爆炸
# 优化后：逐行生成
def read_large_file(file):
for line in file:
yield line
2. 局部变量访问更快
python
# 未优化：频繁访问全局变量
def calculate():
total = 0
for i in range(1000000):
total += math.sqrt(i) # 每次访问全局math
# 优化后：局部化导入
def calculate():
import math # 局部导入
sqrt = math.sqrt # 局部变量缓存
total = 0
for i in range(1000000):
total += sqrt(i)
四、并发与并行
1. 多线程处理 I/O 密集型任务
python
from concurrent.futures import ThreadPoolExecutor
def download(url):
# 模拟下载操作
return requests.get(url).content
urls = ["url1", "url2", "url3"]
with ThreadPoolExecutor(max_workers=5) as executor:
results = list(executor.map(download, urls))
2. 多进程处理 CPU 密集型任务
python
from concurrent.futures import ProcessPoolExecutor
def heavy_computation(n):
# 模拟计算密集型任务
return sum(i*i for i in range(n))
with ProcessPoolExecutor() as executor:
results = executor.map(heavy_computation, [10**6]*10)
五、高级工具与扩展
1. 使用 C 扩展（如 NumPy）
python
# 未优化：纯Python数值计算
total = 0
for i in range(1000000):
total += i * i
# 优化后：使用NumPy向量化
import numpy as np
arr = np.arange(1000000)
total = np.sum(arr ** 2)
2. JIT 编译（Numba/PyPy）
python
from numba import jit
@jit(nopython=True) # 使用Numba加速
def fast_function(n):
total = 0
for i in range(n):
total += i**2
return total
六、性能分析工具
1. 使用 cProfile 定位瓶颈
bash
python -m cProfile -s cumulative my_script.py
2. 行级分析（line_profiler）
python
# 安装：pip install line_profiler
@profile
def slow_function():
# 需要分析的代码
...
# 运行：kernprof -l -v script.py
实战案例：优化数据聚合
原始代码：
python
data = [{"id": i, "value": i%10} for i in range(100000)]
result = {}
for item in data:
key = item["id"] % 10
if key not in result:
result[key] = []
result[key].append(item["value"])
优化后：
python
from collections import defaultdict
data = [{"id": i, "value": i%10} for i in range(100000)]
result = defaultdict(list) # 避免重复判断key是否存在
for item in data:
result[item["id"] % 10].append(item["value"])
关键原则：
1. 先分析再优化：用 cProfile 找到真正瓶颈
2. 空间换时间：合理使用缓存（如 lru_cache）
3. 避免过早优化：优先保证代码可读性
4. 利用硬件特性：并行计算、GPU加速（如 CuPy）
通过组合使用上述策略，通常可使 Python 代码获得 10-100 倍 的性能提升，甚至更高！