python+中如何检验质数

在Python中检验质数的方法有多种，常见的有：直接试除法、埃拉托斯特尼筛法、6k±1优化法。 其中，直接试除法是一种最直观且容易理解的方法，它通过逐一检查一个数是否能被小于等于其平方根的数整除来判断其是否为质数。接下来我们详细介绍这种方法。

直接试除法： 直接试除法是检验质数的最基本方法。其基本思想是：对于一个数 n，试着用 2 到 n-1 之间的所有整数去除它，如果 n 能被其中任意一个整数整除，则 n 不是质数；如果 n 不能被这些数中的任何一个整除，则 n 是质数。为了提高效率，我们只需检查到 n 的平方根即可，因为如果 n = a * b 且 a 和 b 都大于 n 的平方根，那么 a * b 就会大于 n 了。

import math
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

直接试除法的时间复杂度为O(√n)，适合用来判断较小的数是否为质数，对于较大的数，可以使用其他更为高效的算法。

一、直接试除法

直接试除法是质数检测的最基本和最容易理解的方法。它的基本思路是：对于一个给定的数 n，从 2 开始试除，直到 n 的平方根。如果 n 能够被其中任意一个数整除，则 n 不是质数；如果 n 不能被其中任意一个数整除，则 n 是质数。

优化细节

在实现直接试除法时，有几个优化点可以显著提升效率：

只检查到平方根：对于一个数 n，我们只需要检查到 n 的平方根即可。如果 n 可以被一个大于其平方根的数整除，那么它必然也可以被一个小于其平方根的数整除。
跳过偶数：除 2 以外，所有的质数都是奇数。因此，我们可以从 3 开始，每次增加 2 来跳过偶数，从而减少不必要的计算。

import math
def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        if n % i == 0:
            return False
    return True

这种方法的时间复杂度是O(√n)，适用于较小的数。

二、埃拉托斯特尼筛法

埃拉托斯特尼筛法是一种高效的筛选质数的算法，适用于需要找出一段区间内所有质数的情况。其基本思想是：从小到大遍历所有数，将每个数的倍数标记为合数，剩下的就是质数。

实现步骤

创建一个长度为 n+1 的布尔数组，初始值都设置为 True，其中索引代表对应的数。
从 2 开始，将每个数的倍数标记为 False。
遍历整个数组，未被标记为 False 的索引即为质数。

def sieve_of_eratosthenes(n):
    is_prime = [True] * (n + 1)
    p = 2
    while (p * p <= n):
        if is_prime[p]:
            for i in range(p * p, n + 1, p):
                is_prime[i] = False
        p += 1
    return [p for p in range(2, n + 1) if is_prime[p]]

这种方法的时间复杂度是O(n log log n)，适用于需要找出较大区间内所有质数的情况。

三、6k±1优化法

6k±1优化法是一种针对直接试除法的优化方法。其基本思想是：所有大于3的质数都可以表示为6k±1的形式，其中k是一个整数。因为所有大于3的数都可以写成6k, 6k±1, 6k±2, 6k±3, 6k±4, 6k±5，这其中6k, 6k±2, 6k±3, 6k±4都可以被2或3整除，所以只需检查6k±1形式的数即可。

实现步骤

如果 n ≤ 3，直接返回是否为质数。
如果 n 是 2 或 3，返回 True。
如果 n 能被 2 或 3 整除，返回 False。
从 5 开始，检查 n 是否能被 6k±1 的数整除，直到 n 的平方根。

import math
def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

这种方法的时间复杂度接近O(√n)，比直接试除法更高效。

四、分治法

分治法是一种将问题分解为更小的子问题，然后逐步解决的策略。虽然分治法本身不是一种质数检测算法，但是可以用它来优化其他算法。

应用场景

分治法可以用于并行计算，特别是当需要检测多个数是否为质数时。通过将数列分成多个子区间，并行地进行质数检测，可以显著提升效率。

from multiprocessing import Pool
def is_prime_range(start, end):
    primes = []
    for n in range(start, end):
        if is_prime(n):
            primes.append(n)
    return primes
def parallel_prime_detection(n, num_processes):
    pool = Pool(processes=num_processes)
    step = n // num_processes
    tasks = [(i * step, (i + 1) * step) for i in range(num_processes)]
    results = pool.starmap(is_prime_range, tasks)
    pool.close()
    pool.join()
    primes = [prime for sublist in results for prime in sublist]
    return primes
Example usage
n = 100
num_processes = 4
primes = parallel_prime_detection(n, num_processes)
print(primes)

通过使用分治法和并行计算，可以显著提高大规模质数检测的效率。

五、费马小定理

费马小定理是质数检测中的一种概率算法，它基于数论中的费马小定理：如果 p 是质数且 a 是任何小于 p 的整数，则 a^(p-1) ≡ 1 (mod p)。利用这一性质，可以快速判断一个数是否可能为质数。

实现步骤

随机选择一个小于 n 的整数 a。
计算 a^(n-1) % n。
如果结果不为 1，则 n 不是质数。
重复上述步骤若干次，以提高准确性。

import random
def is_prime_fermat(n, k=5):
    if n <= 1:
        return False
    for _ in range(k):
        a = random.randint(2, n - 2)
        if pow(a, n - 1, n) != 1:
            return False
    return True

费马小定理的时间复杂度为O(k log n)，其中 k 是重复测试的次数。虽然这种方法不能保证结果绝对准确，但在实际应用中效果良好。

六、Miller-Rabin测试

Miller-Rabin测试是另一种基于概率的质数检测算法。它比费马小定理更为严谨，是目前最常用的质数检测算法之一。

实现步骤

将 n-1 分解为 d * 2^r 的形式。
随机选择一个小于 n 的整数 a。
检查 a^d % n 是否为 1 或 n-1。
如果上述检查不通过，再检查 (a^(d * 2^j) % n) 是否为 n-1，j 从 0 到 r-1。
重复上述步骤若干次，以提高准确性。

import random
def is_prime_miller_rabin(n, k=5):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    r, d = 0, n - 1
    while d % 2 == 0:
        r += 1
        d //= 2
    def check(a):
        x = pow(a, d, n)
        if x == 1 or x == n - 1:
            return True
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                return True
        return False
    for _ in range(k):
        a = random.randint(2, n - 2)
        if not check(a):
            return False
    return True

Miller-Rabin测试的时间复杂度同样为O(k log n)，其中 k 是重复测试的次数。它比费马小定理更为可靠，是目前质数检测的主流方法之一。

七、AKS算法

AKS算法是一个确定性的质数检测算法，它可以在多项式时间内确定一个数是否为质数。虽然它在实际应用中不如Miller-Rabin测试和费马小定理高效，但它在理论上具有重要意义。

实现步骤

检查 n 是否为完全幂。
找到最小的 r，使得 o_r(n) > log^2(n)。
检查所有小于 r 的质数因子是否整除 n。
检查 (x+a)^n 是否等于 x^n + a (mod n) 对于所有 1 <= a <= √(φ(r)) log(n)。

def is_perfect_power(n):
    for b in range(2, int(math.log2(n)) + 1):
        a = int(n  (1 / b))
        if a  b == n:
            return True
    return False
def find_r(n):
    max_k = math.log2(n)  2
    for r in range(2, n):
        if all(pow(n, k, r) != 0 for k in range(1, int(max_k) + 1)):
            return r
    return n
def is_prime_aks(n):
    if n <= 1:
        return False
    if is_perfect_power(n):
        return False
    r = find_r(n)
    for a in range(2, min(r, n)):
        if math.gcd(a, n) > 1:
            return False
    if n <= r:
        return True
    for a in range(1, int(math.sqrt(r) * math.log2(n)) + 1):
        if pow(a, n, n) != a % n:
            return False
    return True