让Python加速运行的八种实用技巧分享_Python

1. 使用内置函数和库

python的内置函数是用c语言实现的，运行速度比纯python代码快得多。

# 慢速写法
result = []
for item in iterable:
    result.append(func(item))
    
# 快速写法 - 使用map函数
result = list(map(func, iterable))

# 或者使用列表推导式
result = [func(item) for item in iterable]

2. 利用jit编译器 - numba

numba是一个jit(即时)编译器，可以将python函数编译为机器码。

from numba import jit
import numpy as np

@jit(nopython=true)
def sum_array(arr):
    total = 0.0
    for i in range(arr.shape[0]):
        total += arr[i]
    return total

large_array = np.random.rand(10000000)
print(sum_array(large_array))

3. 使用多进程处理cpu密集型任务

python有gil(全局解释器锁)，多线程不适合cpu密集型任务，多进程是更好的选择。

from multiprocessing import pool

def process_data(data):
    # 数据处理逻辑
    return result * 2

if __name__ == '__main__':
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    with pool(4) as p:  # 使用4个进程
        results = p.map(process_data, data)
    print(results)

4. 使用cython将python编译为c

cython允许你编写c扩展模块，显著提升性能。

# 保存为example.pyx
def compute(int n):
    cdef int i
    cdef double res = 0.0
    for i in range(n):
        res += i * i
    return res

然后创建setup.py:

from distutils.core import setup
from cython.build import cythonize

setup(ext_modules=cythonize('example.pyx'))

编译并安装:

python setup.py build_ext --inplace

5. 使用高效的数据结构

选择合适的数据结构可以大幅提升性能。

# 频繁成员检查使用集合(set)而不是列表
large_list = list(range(1000000))
large_set = set(large_list)

# 慢速
if 999999 in large_list:  # o(n)
    pass
    
# 快速
if 999999 in large_set:  # o(1)
    pass

6. 利用numpy和pandas进行向量化操作

避免python级别的循环，使用向量化操作。

import numpy as np

# 慢速 - python循环
def slow_dot(a, b):
    result = 0
    for x, y in zip(a, b):
        result += x * y
    return result

# 快速 - numpy向量化
def fast_dot(a, b):
    return np.dot(a, b)

a = np.random.rand(1000000)
b = np.random.rand(1000000)

%timeit slow_dot(a, b)  # 约500ms
%timeit fast_dot(a, b)  # 约2ms

7. 使用lru_cache缓存函数结果

对于计算密集型且频繁使用相同参数的函数，使用缓存可以避免重复计算。

from functools import lru_cache

@lru_cache(maxsize=128)
def expensive_function(x, y):
    # 模拟复杂计算
    result = 0
    for i in range(x):
        for j in range(y):
            result += i * j
    return result

# 第一次调用会执行计算
print(expensive_function(100, 100))
# 相同参数再次调用会直接返回缓存结果
print(expensive_function(100, 100))

8. 避免不必要的全局变量访问

局部变量访问比全局变量快得多。

# 慢速 - 频繁访问全局变量
global_var = 10

def slow_func():
    total = 0
    for i in range(1000000):
        total += global_var
    return total

# 快速 - 使用局部变量
def fast_func():
    local_var = global_var
    total = 0
    for i in range(1000000):
        total += local_var
    return total

%timeit slow_func()  # 约80ms
%timeit fast_func()  # 约50ms