Python性能优化实战:从代码优化到系统调优
引言
性能优化是后端开发中永恒的话题。作为从Python转向Rust的后端开发者,我深刻体会到性能优化的重要性。虽然Python以简洁易用著称,但在高并发场景下,性能问题可能成为瓶颈。本文将深入探讨Python性能优化的各种策略,帮助你提升代码执行效率。
一、性能分析
1.1 性能指标
| 指标 | 描述 | 测量方法 |
|---|---|---|
| 执行时间 | 代码运行耗时 | time模块、cProfile |
| 内存使用 | 内存占用量 | memory_profiler |
| CPU使用率 | CPU占用百分比 | psutil |
| I/O等待 | 等待IO操作时间 | cProfile |
1.2 使用cProfile分析
python -m cProfile -o profile_results.prof my_script.py
查看分析结果:
import pstats
stats = pstats.Stats('profile_results.prof')
stats.sort_stats('cumulative').print_stats(10)
1.3 行级性能分析
pip install line_profiler
@profile
def slow_function():
# 代码
pass
运行:
kernprof -l -v my_script.py
二、代码级优化
2.1 算法优化
# 不好:O(n²)复杂度
def find_duplicates_bad(items):
duplicates = []
for i in range(len(items)):
for j in range(i+1, len(items)):
if items[i] == items[j]:
duplicates.append(items[i])
return duplicates
# 好:O(n)复杂度
def find_duplicates_good(items):
seen = set()
duplicates = []
for item in items:
if item in seen:
duplicates.append(item)
seen.add(item)
return duplicates
2.2 使用内置函数
# 不好:手动循环
result = []
for item in my_list:
if item > 10:
result.append(item * 2)
# 好:使用列表推导式
result = [item * 2 for item in my_list if item > 10]
# 更好:使用内置函数组合
from functools import map, filter
result = list(map(lambda x: x * 2, filter(lambda x: x > 10, my_list)))
2.3 避免全局变量
# 不好:频繁访问全局变量
global_var = 0
def increment():
global global_var
for _ in range(1_000_000):
global_var += 1
# 好:使用局部变量
def increment_fast():
local_var = 0
for _ in range(1_000_000):
local_var += 1
return local_var
三、数据结构优化
3.1 选择合适的数据结构
# 列表查找慢
my_list = [1, 2, 3, 4, 5]
if 3 in my_list: # O(n)
pass
# 集合查找快
my_set = {1, 2, 3, 4, 5}
if 3 in my_set: # O(1)
pass
# 字典查找快
my_dict = {'a': 1, 'b': 2}
value = my_dict.get('a') # O(1)
3.2 使用collections模块
from collections import defaultdict, deque, Counter
# defaultdict避免KeyError
d = defaultdict(list)
d['key'].append(1)
# deque高效的两端操作
q = deque()
q.append(1)
q.popleft() # O(1)
# Counter计数
c = Counter(['a', 'b', 'a', 'c'])
print(c['a']) # 2
3.3 使用array模块
import array
# 列表存储整数
my_list = [1, 2, 3, 4, 5]
# array更节省内存
my_array = array.array('i', [1, 2, 3, 4, 5])
四、并发与并行
4.1 使用线程池
from concurrent.futures import ThreadPoolExecutor
def fetch_url(url):
import requests
return requests.get(url).text
urls = ['https://example.com', 'https://google.com', 'https://github.com']
with ThreadPoolExecutor(max_workers=3) as executor:
results = list(executor.map(fetch_url, urls))
4.2 使用进程池
from concurrent.futures import ProcessPoolExecutor
def cpu_intensive_task(n):
return sum(i * i for i in range(n))
with ProcessPoolExecutor(max_workers=4) as executor:
results = list(executor.map(cpu_intensive_task, [10_000_000] * 4))
4.3 使用异步IO
import asyncio
import aiohttp
async def fetch_url(session, url):
async with session.get(url) as response:
return await response.text()
async def main():
urls = ['https://example.com', 'https://google.com']
async with aiohttp.ClientSession() as session:
tasks = [fetch_url(session, url) for url in urls]
results = await asyncio.gather(*tasks)
print(results)
asyncio.run(main())
五、使用高效库
5.1 使用NumPy
import numpy as np
# Python列表
python_list = [1, 2, 3, 4, 5]
result = [x * 2 for x in python_list]
# NumPy数组
numpy_array = np.array([1, 2, 3, 4, 5])
result = numpy_array * 2 # 更快
5.2 使用Pandas
import pandas as pd
# 手动处理CSV
with open('data.csv') as f:
lines = f.readlines()
# 使用Pandas
df = pd.read_csv('data.csv')
5.3 使用Cython
# example.pyx
def fibonacci(int n):
cdef int a, b, i
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
六、JIT编译
6.1 使用PyPy
pypy my_script.py
6.2 使用Numba
from numba import jit
@jit(nopython=True)
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
七、系统级优化
7.1 使用连接池
import psycopg2.pool
connection_pool = psycopg2.pool.SimpleConnectionPool(
minconn=5,
maxconn=20,
host='localhost',
database='mydb',
user='user',
password='pass'
)
conn = connection_pool.getconn()
# 使用连接
connection_pool.putconn(conn)
7.2 缓存策略
from functools import lru_cache
@lru_cache(maxsize=128)
def expensive_function(x):
# 计算密集型操作
return x * x
7.3 批量操作
# 逐行插入
for item in items:
cursor.execute('INSERT INTO table VALUES (%s)', (item,))
# 批量插入
cursor.executemany('INSERT INTO table VALUES (%s)', [(item,) for item in items])
八、性能监控
8.1 使用Prometheus
from prometheus_client import Counter, Histogram, start_http_server
REQUEST_COUNT = Counter('requests_total', 'Total requests')
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')
@REQUEST_LATENCY.time()
def handle_request():
REQUEST_COUNT.inc()
# 处理请求
8.2 日志监控
import logging
import time
logging.basicConfig(level=logging.INFO)
def timed_function(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
elapsed = time.time() - start
logging.info(f"{func.__name__} took {elapsed:.2f}s")
return result
return wrapper
九、总结
性能优化是一个持续的过程。通过分析瓶颈、优化算法、使用高效库和合理的并发策略,我们可以显著提升Python代码的性能。
关键要点:
- 先分析后优化:使用cProfile找到瓶颈
- 算法优化优先:选择合适的数据结构和算法
- 使用内置函数:避免手动循环
- 并发处理:使用线程池、进程池或异步IO
- 使用高效库:NumPy、Pandas、Numba等
从Python转向Rust后,我发现Rust在性能方面有天然优势,但Python的生态和易用性仍然是很多场景的首选。
延伸阅读
- cProfile官方文档
- Numba官方文档
- Pandas性能指南
- 《Python高性能编程》书籍
588



被折叠的 条评论
为什么被折叠?



