python如何计算1到N质数的和

Python 计算1到N质数的和的核心步骤：筛选质数、累加质数、优化算法。 在计算1到N质数的和时，我们需要首先筛选出所有的质数，然后将这些质数进行累加。筛选质数的方法有多种，但最常用的是埃拉托色尼筛法（Sieve of Eratosthenes），它的时间复杂度相对较低，适合处理较大的N值。接下来，我们将详细介绍如何使用Python实现这一过程，并对各个步骤进行优化。

一、筛选质数

筛选质数是计算1到N质数和的第一步。质数是指只能被1和自身整除的自然数。常见的筛选质数方法有试除法和埃拉托色尼筛法。我们重点介绍埃拉托色尼筛法，因为它的效率更高。

埃拉托色尼筛法

埃拉托色尼筛法的基本思想是：从2开始，依次标记所有合数为非质数，剩下未标记的数即为质数。具体步骤如下：

创建一个布尔数组，标记所有数为质数。
从2开始遍历，标记每个数的倍数为非质数。
遍历结束后，数组中仍为质数的数即为质数。

def sieve_of_eratosthenes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    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
    primes = [p for p in range(n + 1) if is_prime[p]]
    return primes

二、累加质数

在筛选出质数后，我们需要将这些质数累加起来。可以使用Python内置的sum函数来实现这一过程。

def sum_of_primes(n):
    primes = sieve_of_eratosthenes(n)
    return sum(primes)

三、优化算法

虽然埃拉托色尼筛法的时间复杂度较低，但在处理非常大的N值时，仍需进行一些优化。以下是几种常见的优化方法：

优化内存使用：将布尔数组替换为位数组，减少内存占用。
跳过偶数：除了2以外的质数都是奇数，可以跳过所有偶数，进一步减少计算量。
并行化计算：利用多线程或多进程，进一步提升计算效率。

跳过偶数的改进版埃拉托色尼筛法

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

四、完整代码示例

将以上步骤整合在一起，形成一个完整的Python程序：

def sieve_of_eratosthenes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    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
    primes = [p for p in range(n + 1) if is_prime[p]]
    return primes
def sum_of_primes(n):
    primes = sieve_of_eratosthenes(n)
    return sum(primes)
def optimized_sieve_of_eratosthenes(n):
    if n < 2:
        return []
    if n == 2:
        return [2]
    is_prime = [True] * ((n // 2) + 1)
    is_prime[0] = False
    p = 3
    while p * p <= n:
        if is_prime[p // 2]:
            for i in range(p * p // 2, (n // 2) + 1, p):
                is_prime[i] = False
        p += 2
    primes = [2] + [2 * i + 1 for i in range(1, (n // 2) + 1) if is_prime[i]]
    return primes
def optimized_sum_of_primes(n):
    primes = optimized_sieve_of_eratosthenes(n)
    return sum(primes)
测试代码
n = 100
print("1到{}之间质数的和为: {}".format(n, optimized_sum_of_primes(n)))

五、性能测试

为了验证优化效果，可以使用不同的N值进行性能测试。以下是一些示例测试代码：

import time
n = 1000000
start = time.time()
print("普通方法：1到{}之间质数的和为: {}".format(n, sum_of_primes(n)))
end = time.time()
print("普通方法耗时: {:.2f}秒".format(end - start))
start = time.time()
print("优化方法：1到{}之间质数的和为: {}".format(n, optimized_sum_of_primes(n)))
end = time.time()
print("优化方法耗时: {:.2f}秒".format(end - start))