Python嵌套列表搜索优化：利用Numba加速素数组合查找-Python教程-PHP中文网

Python嵌套列表搜索优化：利用Numba加速素数组合查找

碧海醫心

发布： 2025-09-09 17:40:02

原创

187人浏览过

python嵌套列表搜索优化：利用numba加速素数组合查找

本文针对在大量素数中寻找满足特定条件的组合这一计算密集型问题，提供了一种基于Numba的优化方案。通过预计算有效的素数对组合，并利用Numba的即时编译和并行计算能力，显著提升搜索效率，从而在合理时间内找到符合要求的最小素数组合。文章详细介绍了算法实现和代码示例，帮助读者理解并应用Numba加速Python代码。

在处理大规模数据时，Python的执行效率往往成为瓶颈。对于诸如在大量素数中寻找特定组合的问题，如果使用纯Python实现，计算时间可能会非常长。本文将介绍如何使用Numba库来优化这类问题，并通过一个具体的例子——寻找满足特定条件的最小素数组合——来展示Numba的强大功能。

Numba简介

Numba是一个开源的Python编译器，它可以将Python代码编译成机器码，从而显著提高程序的运行速度。Numba特别适合于数值计算密集型的任务，例如循环、数学运算等。它通过即时编译（Just-In-Time, JIT）技术，在运行时将Python代码编译成机器码，避免了解释执行的开销。

问题描述

我们需要在一定范围内的素数中，找到一个包含5个素数的集合，满足以下条件：

立即学习“Python免费学习笔记（深入）”；

集合中的素数按升序排列：p1 < p2 < p3 < p4 < p5。
集合中任意两个素数组合（如p1和p2，组合成p1p2和p2p1）也必须是素数。
集合中所有素数的和大于某个给定的阈值（例如100,000），并且是满足上述条件的最小和。

优化思路

直接搜索所有可能的素数组合效率极低。为了提高效率，可以采用以下策略：

纳米搜索

纳米搜索：360推出的新一代AI搜索引擎

查看详情

预计算素数对组合： 首先，生成指定范围内的所有素数。然后，预先计算这些素数两两组合后是否仍然是素数。将结果存储在一个二维数组中，用于后续快速查找。
利用Numba加速： 使用Numba的@njit装饰器将计算密集型的函数编译成机器码。
并行计算： 使用Numba的prange函数实现并行循环，充分利用多核CPU的计算能力。

代码实现

以下是使用Numba优化素数组合查找的示例代码：

import numpy as np
from numba import njit, prange

@njit
def is_prime(a):
    """判断一个数是否为素数"""
    if a < 2:
        return False
    for x in range(2, int(a**0.5) + 1):
        if a % x == 0:
            return False
    return True

@njit
def str_to_int(s):
    """将字符串转换为整数"""
    final_index, result = len(s) - 1, 0
    for i, v in enumerate(s):
        result += (ord(v) - 48) * (10 ** (final_index - i))
    return result

@njit
def generate_primes(n):
    """生成小于n的所有素数"""
    out = []
    for i in range(3, n + 1):
        if is_prime(i):
            out.append(i)
    return out

@njit(parallel=True)
def get_comb(n=100_000):
    """寻找满足条件的最小素数组合"""
    # 生成所有小于n的素数
    primes = generate_primes(n)
    n_primes = len(primes)

    # 生成所有有效的素数组合
    combs = np.zeros((n_primes, n_primes), dtype=np.uint8)

    for i in prange(n_primes):
        for j in prange(i + 1, n_primes):
            p1, p2 = primes[i], primes[j]

            c1 = str_to_int(f"{p1}{p2}")
            c2 = str_to_int(f"{p2}{p1}")

            if not is_prime(c1) or not is_prime(c2):
                continue

            combs[i, j] = 1

    all_combs = []

    for i_p1 in prange(0, n_primes):
        for i_p2 in prange(i_p1 + 1, n_primes):
            if combs[i_p1, i_p2] == 0:
                continue
            for i_p3 in prange(i_p2 + 1, n_primes):
                if combs[i_p1, i_p3] == 0:
                    continue
                if combs[i_p2, i_p3] == 0:
                    continue
                for i_p4 in prange(i_p3 + 1, n_primes):
                    if combs[i_p1, i_p4] == 0:
                        continue
                    if combs[i_p2, i_p4] == 0:
                        continue
                    if combs[i_p3, i_p4] == 0:
                        continue
                    for i_p5 in prange(i_p4 + 1, n_primes):
                        if combs[i_p1, i_p5] == 0:
                            continue
                        if combs[i_p2, i_p5] == 0:
                            continue
                        if combs[i_p3, i_p5] == 0:
                            continue
                        if combs[i_p4, i_p5] == 0:
                            continue

                        p1, p2, p3, p4, p5 = (
                            primes[i_p1],
                            primes[i_p2],
                            primes[i_p3],
                            primes[i_p4],
                            primes[i_p5],
                        )

                        ccomb = np.array([p1, p2, p3, p4, p5], dtype=np.int64)
                        if np.sum(ccomb) < n:
                            continue

                        all_combs.append(ccomb)
                        print(ccomb) #输出符合要求的组合，方便调试
                        break # 找到一个组合就跳出，因为要找最小和

    return all_combs


all_combs = np.array(get_comb())
print()
print("Minimal combination:")
print(all_combs[np.sum(all_combs, axis=1).argmin()])

登录后复制

代码解释：

is_prime(a): 判断一个数a是否为素数。
str_to_int(s): 将字符串s转换为整数。用于将两个素数拼接成一个整数。
generate_primes(n): 生成小于n的所有素数。
get_comb(n): 核心函数，寻找满足条件的最小素数组合。
- 首先，生成小于n的所有素数。
- 然后，预计算所有有效的素数组合，存储在combs数组中。combs[i, j] = 1表示primes[i]和primes[j]可以组合成素数。
- 最后，遍历所有可能的素数组合，找到满足条件的最小组合。

注意事项：