python脚本如何在多个cpu上跑

Python脚本在多个CPU上跑的方式有：使用多线程、使用多进程、使用并行计算库、使用分布式计算框架。其中，使用多进程是最常见的方式之一。多进程能够充分利用多核CPU的性能，提升计算效率。

使用多进程进行并行计算

多进程是通过创建多个进程来实现并行计算的，在Python中可以使用multiprocessing库来实现多进程。multiprocessing库允许你创建多个独立的进程，这些进程可以在多个CPU上并行运行。

1、创建多进程

可以通过multiprocessing.Process类来创建多进程。下面是一个简单的示例：

import multiprocessing
def worker(num):
    """线程工作函数"""
    print(f'Worker: {num}')
if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()

在这个示例中，我们创建了5个进程，每个进程都会执行worker函数。每个进程将在不同的CPU上运行，从而实现并行计算。

2、使用进程池

进程池（Pool）是multiprocessing库提供的另一种方式，可以更方便地管理多个进程。使用进程池可以更容易地提交多个任务，并让它们在多个CPU上并行运行。

import multiprocessing
def worker(num):
    """线程工作函数"""
    print(f'Worker: {num}')
if __name__ == '__main__':
    with multiprocessing.Pool(processes=4) as pool:
        pool.map(worker, range(10))

在这个示例中，我们创建了一个包含4个进程的进程池，并使用pool.map方法将任务分配到这些进程中。每个进程将运行worker函数，并行处理输入的10个任务。

使用并行计算库

除了multiprocessing库，Python中还有其他并行计算库，如concurrent.futures和joblib。

1、concurrent.futures

concurrent.futures模块提供了一个高级接口来管理线程和进程。可以使用ThreadPoolExecutor或ProcessPoolExecutor来实现并行计算。

from concurrent.futures import ProcessPoolExecutor
def worker(num):
    """线程工作函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    with ProcessPoolExecutor(max_workers=4) as executor:
        results = executor.map(worker, range(10))
        for result in results:
            print(result)

在这个示例中，我们使用ProcessPoolExecutor创建了一个包含4个进程的进程池，并使用executor.map方法并行处理输入的10个任务。

2、joblib

joblib是一个专门用于并行计算的库，特别适合科学计算和数据处理任务。它提供了简单易用的API来实现并行计算。

from joblib import Parallel, delayed
def worker(num):
    """线程工作函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    results = Parallel(n_jobs=4)(delayed(worker)(i) for i in range(10))
    for result in results:
        print(result)

在这个示例中，我们使用joblib.Parallel创建了一个包含4个进程的进程池，并使用delayed函数将任务分配到这些进程中。

使用分布式计算框架

对于更大规模的并行计算任务，可以考虑使用分布式计算框架，如Dask、Ray和Apache Spark。

1、Dask

Dask是一个并行计算库，可以在单机或集群上进行并行计算。它能够处理大规模的数据集，适用于数据科学和机器学习任务。

import dask.array as da
创建一个大规模数组
x = da.random.random((10000, 10000), chunks=(1000, 1000))
计算数组的均值
result = x.mean().compute()
print(result)

在这个示例中，我们使用Dask创建了一个大规模数组，并计算了数组的均值。Dask会自动将计算任务分配到多个CPU上进行并行处理。

2、Ray

Ray是一个高性能的分布式计算框架，适用于机器学习、数据处理和强化学习等任务。它提供了简单易用的API来实现并行计算和分布式计算。

import ray
ray.init()
@ray.remote
def worker(num):
    """线程工作函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    results = ray.get([worker.remote(i) for i in range(10)])
    for result in results:
        print(result)

在这个示例中，我们使用Ray创建了一个包含多个进程的集群，并使用ray.remote装饰器将任务分配到这些进程中。

3、Apache Spark

Apache Spark是一个分布式计算框架，适用于大规模数据处理和分析任务。它提供了丰富的API来实现并行计算和分布式计算。

from pyspark.sql import SparkSession
创建SparkSession
spark = SparkSession.builder.appName("example").getOrCreate()
创建一个DataFrame
data = [("Alice", 1), ("Bob", 2), ("Cathy", 3)]
df = spark.createDataFrame(data, ["name", "age"])
计算DataFrame的均值
result = df.agg({"age": "avg"}).collect()
print(result)

在这个示例中，我们使用Apache Spark创建了一个包含多个节点的集群，并计算了DataFrame的均值。Spark会自动将计算任务分配到多个节点上进行并行处理。

小结

在Python中，有多种方式可以实现多CPU并行计算，包括使用多进程、使用并行计算库和使用分布式计算框架。多进程是最常见的方式之一，可以通过multiprocessing库来实现。此外，可以使用concurrent.futures、joblib等并行计算库，或者使用Dask、Ray、Apache Spark等分布式计算框架来处理更大规模的并行计算任务。根据具体的应用场景和需求，选择合适的并行计算方式，可以显著提升计算效率和性能。