Python执行速度慢的原因及全面优化方案

# 低效写法
data = []
for i in range(1000000):
    data.append(i * 2)

# 高效写法
data = [i * 2 for i in range(1000000)]  # 列表推导式快30%

# 低效：手动实现字符串连接
result = ""
for s in string_list:
    result += s  # 每次创建新字符串

# 高效：使用str.join()
result = "".join(string_list)  # 快100倍

# 慢：频繁访问全局变量
global_var = 10
def func():
    for i in range(1000000):
        val = global_var * i

# 快：使用局部变量
def func_fast():
    local_var = global_var
    for i in range(1000000):
        val = local_var * i  # 快20-30%

# O(n²) → O(n) 优化示例
def find_pairs_naive(nums, target):
    """暴力搜索"""
    result = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                result.append((nums[i], nums[j]))
    return result

def find_pairs_optimized(nums, target):
    """哈希表优化"""
    seen = set()
    result = []
    for num in nums:
        complement = target - num
        if complement in seen:
            result.append((complement, num))
        seen.add(num)
    return result  # 万级数据快1000倍

# 斐波那契数列计算优化
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)  # 从O(2^n)降到O(n)

# 低效：立即计算所有结果
def process_all(data):
    return [expensive_compute(x) for x in data]  # 内存爆炸风险

# 高效：生成器延迟计算
def process_lazy(data):
    for x in data:
        yield expensive_compute(x)  # 按需计算

# 安装PyPy
pypy3 -m pip install numpy  # 多数库兼容

# 执行脚本
pypy3 my_script.py

# cython: language_level=3
def cython_compute(int n):
    cdef int i, total = 0
    for i in range(n):
        total += i
    return total

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize("compute.pyx"))

from multiprocessing import Pool

def process_chunk(chunk):
    return [x**2 for x in chunk]

if __name__ == '__main__':
    data = range(10**7)
    with Pool(4) as p:  # 4个进程
        results = p.map(process_chunk, [data[i::4] for i in range(4)])

import numpy as np

# 慢：Python循环
def slow_dot(a, b):
    total = 0
    for x, y in zip(a, b):
        total += x * y
    return total

# 快：NumPy向量化
def fast_dot(a, b):
    return np.dot(np.array(a), np.array(b))  # 快100-1000倍

from numba import jit
import random

@jit(nopython=True)  # 脱离Python解释器
def monte_carlo_pi(n):
    count = 0
    for _ in range(n):
        x = random.random()
        y = random.random()
        if x**2 + y**2 < 1:
            count += 1
    return 4 * count / n  # 比纯Python快50-100倍

def compute_naive(n):
    result = 0
    for i in range(n):
        if i % 2 == 0:
            result += i ** 2
        else:
            result -= i ** 0.5
    return result
# 10^6次调用耗时：3.2秒

@jit(nopython=True)
def compute_optimized(n):
    result = 0.0
    for i in range(n):
        if i % 2 == 0:
            result += i ** 2
        else:
            result -= i ** 0.5
    return result
# 10^6次调用耗时：0.04秒 (80倍提升)