在Python中，性能优化需要结合语言特性和算法思维。以下是经过工业级验证的 20个核心性能优化技巧，涵盖从微观代码优化到宏观架构设计：

一、基础优化策略

1.选择高效数据结构

# 查找操作对比（100万数据）
lst = list(range(1_000_000))
s = set(lst)

%timeit 999999 in lst  # 线性查找：~25ms
%timeit 999999 in s    # 哈希查找：~0.0001ms（快25万倍）

2.局部变量加速

def slow():
    global_var = [i for i in range(10_000)]
    return len(global_var)  # 每次访问全局变量

def fast():
    local_var = [i for i in range(10_000)]
    return len(local_var)  # 访问局部变量快15%

%timeit slow()  # 152 μs
%timeit fast()  # 130 μs

3.字符串拼接优化

# 错误方式（每次拼接创建新对象）
s = ""
for i in range(10000):
    s += str(i)  # O(n^2)时间复杂度

# 正确方式（join一次性分配内存）
parts = []
for i in range(10000):
    parts.append(str(i))
s = "".join(parts)  # 快50倍

二、循环与计算优化

4.向量化计算（NumPy）

import numpy as np

# 传统循环（慢）
def sum_python(n):
    return sum(i*i for i in range(n))

# NumPy向量化（快100倍）
def sum_numpy(n):
    return np.arange(n).sum() ** 2

%timeit sum_python(1_000_000)  # 120ms
%timeit sum_numpy(1_000_000)   # 1.2ms

5.避免重复计算

# 优化前
for i in range(len(data)):
    result = expensive_calc(data[i]) * scale_factor  # 每次计算scale_factor

# 优化后
scaled_factor = expensive_calc(scale_factor)  # 预先计算
for i in range(len(data)):
    result = data[i] * scaled_factor

6.生成器替代列表

# 内存消耗对比
def get_numbers_list(n):
    return [i for i in range(n)]  # 消耗O(n)内存

def get_numbers_gen(n):
    yield from range(n)  # 消耗O(1)内存

# 处理1GB数据时，生成器可避免内存溢出

三、高级优化技术

7.JIT编译（Numba）

from numba import jit

@jit(nopython=True)
def monte_carlo_pi(n):
    count = 0
    for _ in range(n):
        x, y = np.random.random(), np.random.random()
        if x**2 + y**2 < 1:
            count += 1
    return 4 * count / n  # 比纯Python快200倍

8.内存视图（memoryview）

data = bytearray(b'x' * 100_000_000)
view = memoryview(data)  # 零拷贝操作
processed = view[10_000:20_000]  # 不复制底层数据

9.多进程并行（multiprocessing）

from multiprocessing import Pool

def process_chunk(chunk):
    return sum(x*x for x in chunk)

with Pool(4) as p:
    results = p.map(process_chunk, [data[i::4] for i in range(4)])  # 4核并行

四、I/O性能优化

10.批量文件操作

# 错误方式（多次I/O）
with open('data.txt', 'w') as f:
    for item in data:
        f.write(str(item) + '\n')  # 每次write有系统调用开销

# 正确方式（单次I/O）
content = '\n'.join(map(str, data))
with open('data.txt', 'w') as f:
    f.write(content)  # 减少系统调用

11.压缩传输数据

import zlib
data = b'x' * 100_000_000
compressed = zlib.compress(data)  # 体积缩小10倍

五、工具链优化

12.使用PyPy解释器

# 对计算密集型代码可提升3-10倍速度
pypy3 your_script.py

13.Cython混合编程

# cython_test.pyx
def cython_sum(int n):
    cdef long total = 0
    cdef int i
    for i in range(n):
        total += i
    return total  # 编译后比纯Python快50倍

14.性能分析工具

# 使用py-spy进行采样分析
pip install py-spy
py-spy top --pid <PID>  # 实时查看CPU热点

六、架构级优化

15.缓存计算结果

from functools import lru_cache

@lru_cache(maxsize=1024)
def expensive_call(param):
    return heavy_computation(param)  # 相同参数直接返回缓存

16.异步I/O（asyncio）

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()  # 非阻塞I/O

# 并发处理100个请求比同步快10倍

七、优化效果对比

终极优化原则

1. 先测量后优化：用cProfile定位真正瓶颈
2. 二八法则：20%的代码消耗80%性能
3. 空间换时间：合理使用缓存和预处理
4. 避免过度优化：保持代码可读性

记住：

"过早优化是万恶之源" —— Donald Knuth
但正确的优化能让程序从"不可用"变为"高效"！