如何提升python的运行效率-优快云博客

本文链接：https://blog.youkuaiyun.com/sui_152/article/details/147148949

文章目录

提升Python的运行效率需要从代码优化、数据结构选择、算法改进、利用高效库及并行计算等多方面入手。以下通过具体示例和原因分析，介绍常见的优化方法：

1.使用更高效的数据结构

示例：集合（Set） vs 列表（List）的成员检查

# 列表查找（O(n)时间复杂度）
my_list = [i for i in range(10**6)]
if 999999 in my_list:  # 需要遍历整个列表
    pass

# 集合查找（O(1)时间复杂度）
my_set = set(my_list)
if 999999 in my_set:  # 哈希表直接定位
    pass

原因：集合基于哈希表实现，成员检查时间复杂度为O(1)，而列表为O(n)。在频繁查找的场景中，集合效率显著更高。

2.避免不必要的循环

示例：使用向量化操作代替循环（如NumPy）

# 低效的纯Python循环
import time
data = [i for i in range(10**6)]
start = time.time()
squared = [x**2 for x in data]  # 列表推导式
print(f"Python循环耗时: {time.time() - start:.4f}秒")

# 高效的NumPy向量化操作
import numpy as np
data_np = np.array(data)
start = time.time()
squared_np = data_np ** 2  # 底层C实现的向量化操作
print(f"NumPy耗时: {time.time() - start:.4f}秒")

Python循环耗时: 0.1250秒
NumPy耗时: 0.0020秒

原因：NumPy底层使用C语言实现，避免Python解释器的开销，且支持SIMD指令并行计算。

3.利用生成器（Generator）和惰性计算

示例：处理大型文件时节省内存

# 低效方法：一次性读取整个文件
with open("large_file.txt", "r") as f:
    lines = f.readlines()  # 所有行存入内存
    for line in lines:
        process(line)

# 高效方法：逐行读取（生成器）
with open("large_file.txt", "r") as f:
    for line in f:  # 逐行生成，不占用全部内存
        process(line)

原因：生成器逐行生成数据，避免一次性加载所有内容到内存，适合处理大型数据集。

4.减少全局变量访问

示例：将频繁访问的全局变量转为局部变量

# 低效写法：频繁访问全局变量
global_var = 100

def slow_func():
    for _ in range(10**6):
        result = global_var * 2  # 每次访问全局变量

# 高效写法：局部变量
def fast_func():
    local_var = global_var  # 将全局变量复制到局部
    for _ in range(10**6):
        result = local_var * 2  # 访问局部变量

原因：Python访问局部变量（通过LOAD_FAST字节码）比全局变量（LOAD_GLOBAL）更快。

5.使用内置函数和库

示例：字符串拼接用join代替+

# 低效写法：频繁使用 "+"
result = ""
for s in ["a", "b", "c", ... , "z"]:  # 假设列表很大
    result += s  # 每次创建新字符串对象

# 高效写法：使用 "".join()
result = "".join(["a", "b", "c", ... , "z"])

原因：字符串是不可变对象，+操作会反复创建新对象，而join一次性分配内存完成拼接,内置函数通常由 C 编写，速度快于纯 Python 实现。

6.使用缓存避免重复计算

示例：functools.lru_cache缓存函数结果

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(35))  # 无缓存时极慢，缓存后快速计算

原因：缓存递归函数的中间结果，避免重复计算，时间复杂度从指数级降至线性级。

7.并行计算（多进程/多线程

示例：使用multiprocessing加速CPU密集型任务

import multiprocessing
import time

def heavy_computation(n):
    return sum(i*i for i in range(n))

# 单进程
start = time.time()
results = [heavy_computation(10**6) for _ in range(4)]
print(f"单进程耗时: {time.time() - start:.2f}秒")

# 多进程
start = time.time()
with multiprocessing.Pool(4) as pool:
    results = pool.map(heavy_computation, [10**6]*4)
print(f"4进程耗时: {time.time() - start:.2f}秒")
输出结果（假设4核CPU）：

复制
单进程耗时: 2.50秒
4进程耗时: 0.80秒

原因：Python的全局解释器锁（GIL）限制多线程的CPU并行，但多进程可绕过GIL，充分利用多核。

8.使用JIT编译器（如Numba或PyPy）

示例：Numba加速数值计算

from numba import jit
import time

# 普通Python函数
def sum_squares(n):
    total = 0
    for i in range(n):
        total += i**2
    return total

# Numba加速的版本
@jit
def sum_squares_numba(n):
    total = 0
    for i in range(n):
        total += i**2
    return total

start = time.time()
sum_squares(10**8)
print(f"普通Python耗时: {time.time() - start:.2f}秒")

start = time.time()
sum_squares_numba(10**8)
print(f"Numba耗时: {time.time() - start:.2f}秒")


输出结果：
普通Python耗时: 12.34秒
Numba耗时: 0.45秒

原因：Numba将Python函数编译为机器码，避免解释器开销，尤其适合数值计算。

总结与选择策略

优化方法	场景	性能提升关键
高效数据结构	频繁查找/去重	降低时间复杂度（如O(n)→O(1)）
向量化库（NumPy）	数值计算/大规模数据处理	底层C实现+并行计算
生成器	处理大型文件/流式数据	减少内存占用
多进程/多线程	CPU密集型/I/O密集型任务利用多核/异步I/O
JIT编译器（Numba）数值循环/复杂算法	编译为机器码，绕过解释器
缓存（lru_cache）	递归/重复计算函数	避免重复计算