加速 Python 代码的八个优秀实用技巧

import numpy as np
import time

# 定义一个Python列表
python_list = [1, 2, 3, 4, 5]

# 使用纯Python循环计算平方的时间测试
def measure_time(function, argument):
    start_time = time.time()
    result = function(argument)
    end_time = time.time()
    return result, end_time - start_time

# 定义纯Python循环计算平方的函数
def square_elements_python(lst):
    squared_lst = []
    for num in lst:
        squared_lst.append(num ** 2)
    return squared_lst

# 计算并输出纯Python循环方法执行时间和结果
python_squares, python_time = measure_time(square_elements_python, python_list)
print(f"纯Python循环方法: {python_squares}, Time taken: {python_time} seconds")

# 转换为NumPy数组并使用向量化操作
start_time = time.time()
numpy_array = np.array(python_list)
numpy_squares = numpy_array ** 2
end_time = time.time()

# 输出NumPy向量化操作执行时间
numpy_time = end_time - start_time
print(f"NumPy向量化操作: {numpy_squares.tolist()}, Time taken: {numpy_time} seconds")
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

纯Python循环方法: [1, 4, 9, 16, 25], Time taken: 4.5299530029296875e-06 seconds
NumPy向量化操作: [1, 4, 9, 16, 25], Time taken: 0.00020122528076171875 seconds
1.
2.

import numpy as np
from numba import jit

@jit(nopython=True)
def sum_array(arr: np.ndarray) -> float:
    result = 0.0
    for i in range(arr.shape[0]):
        result += arr[i]
    return result

arr = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
print(sum_array(arr))
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

# 避免：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = list1 + list2

# 推荐：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 这里不会创建新的列表对象，而是直接在原地扩展list1
list1.extend(list2)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

numbers = [1, 2, 3, 4, 5]
squared_numbers = [num ** 2 for num in numbers]
for squared_num in squared_numbers:
    print(squared_num)
1.
2.
3.
4.

1
4
9
16
25
1.
2.
3.
4.
5.

numbers = [1, 2, 3, 4, 5]
squared_numbers = (num ** 2 for num in numbers)
for squared_num in squared_numbers:
    print(squared_num)
1.
2.
3.
4.

import multiprocessing as mp

def cpu_bound_task(n):
    # 模拟的CPU密集型计算任务
    result = 0
    for i in range(n):
        result += i * i
    return result

if __name__ == "__main__":
    inputs = [1_000_000 + x for x in range(10)]  # 多个需要处理的数据单元

    with mp.Pool(processes=mp.cpu_count()) as pool:  # 使用所有可用CPU核心数
        results = pool.map(cpu_bound_task, inputs)  # 将任务分配到各个进程中并行处理

    print(f"Results: {results}")
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

from functools import lru_cache

@lru_cache(maxsize=None)  # 缓存所有结果，可以根据实际情况设置缓存大小
def expensive_computation(x):
    # 假设这是一个计算成本很高的函数
    print("Computing...")
    return x ** x

# 第一次调用时会执行计算
result1 = expensive_computation(5)
# 第二次调用时会从缓存中获取结果，不再执行计算
result2 = expensive_computation(5)
print(result1 == result2)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

import asyncio

async def fetch(url):
    # 异步网络请求
    response = await asyncio.get_event_loop().run_in_executor(None, fetch_from_network, url)
    return response

async def main():
    tasks = [fetch('http://example.com') for _ in range(10)]
    responses = await asyncio.gather(*tasks)
    for response in responses:
        process_response(response)

# 启动事件循环
asyncio.run(main())
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

# example_cython.pyx
def cython_power(int x):
    return x ** x
1.
2.
3.

$ cython example_cython.pyx
$ gcc -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing -I/usr/include/python3.7 -o example_cython.cpython-37m-x86_64-linux-gnu.so example_cython.c
1.
2.

import example_cython

# 使用Cython优化后的函数
result = example_cython.cython_power(5)
print(result)
1.
2.
3.
4.
5.