Python 3.x 有效地找到一定范围内的素数

这是我为python3的Eratosthenes筛选找到的一个算法代码。我想做的是编辑它，这样我可以输入一个底部和顶部的范围，然后输入一个素数列表，一直到底部，它将输出该范围内的素数列表。 然而，我不太清楚如何做到这一点。 如果你能帮忙，我将不胜感激

from math import sqrt
def sieve(end):  
    if end < 2: return []  

    #The array doesn't need to include even numbers  
    lng = ((end//2)-1+end%2)  

    # Create array and assume all numbers in array are prime  
    sieve = [True]*(lng+1)  

    # In the following code, you're going to see some funky  
    # bit shifting and stuff, this is just transforming i and j  
    # so that they represent the proper elements in the array.  
    # The transforming is not optimal, and the number of  
    # operations involved can be reduced.  

    # Only go up to square root of the end  
    for i in range(int(sqrt(end)) >> 1):  

        # Skip numbers that aren’t marked as prime  
        if not sieve[i]: continue  

        # Unmark all multiples of i, starting at i**2  
        for j in range( (i*(i + 3) << 1) + 3, lng, (i << 1) + 3):  
            sieve[j] = False  

    # Don't forget 2!  
    primes = [2]  

    # Gather all the primes into a list, leaving out the composite numbers  
    primes.extend([(i << 1) + 3 for i in range(lng) if sieve[i]])  

    return primes

从数学导入sqrt
def筛（端）：
如果结束<2：返回[]
#数组不需要包含偶数
液化天然气=（（结束//2）-1+结束%2）
#创建数组并假设数组中的所有数字都是素数
筛子=[正确]*（液化天然气+1）
#在下面的代码中，您将看到一些时髦的东西
#移位之类的，这只是改变了i和j
#因此，它们表示数组中的适当元素。
#转换不是最优的，并且
#所涉及的业务可以减少。
#只升到末端的平方根
对于范围内的i（int（sqrt（end））>>1）：
#跳过未标记为素数的数字
如果没有筛选[i]：继续
#从i**2开始，取消标记i的所有倍数
对于范围（（i*（i+3）中的j，您已经有了从2到
end
的素数，因此您只需要过滤返回的列表。
一种方法是使用
end=top
运行筛选代码，并修改最后一行，只给出大于底部的数字：

如果范围与其大小相比较小（即上下比下小），则最好使用不同的算法：

从底部开始，迭代奇数，检查它们是否为素数。您需要一个isprime（n）函数，它只检查n是否可被从1到sqrt（n）的所有奇数整除：

def isprime（n）：
i=2
虽然（i*i我认为以下方法有效：

def extend_erathostene(A, B, prime_up_to_A):
    sieve = [ True ]* (B-A)
    for p in prime_up_to_A:
        # first multiple of p greater than A
        m0 = ((A+p-1)/p)*p
        for m in range( m0, B, p):
            sieve[m-A] = False
    limit = int(ceil(sqrt(B)))
    for p in range(A,limit+1):
        if sieve[p-A]:
            for m in range(p*2, B, p):
                sieve[m-A] = False 
    return prime_up_to_A + [ A+c for (c, isprime) in enumerate(sieve) if isprime]

这个问题被称为“埃拉托斯坦的分段筛”谷歌提供了一些有用的参考资料。
这是针对euler 216的，我可以在100秒内在我的上网本上筛选出1亿的所有素数，但我需要它们高达1.59亿的素数，它们的sqrt为50000000^2*10，约为158，并且发生了变化，所以我需要在新列表中列出最后的5900万个素数，因为我有一个内存错误。我是一名机械工程师我是佐治亚理工学院的一名学生，我正在努力学习python的独特性，以尽可能避免使用matlab，因为它对上下文中的甲烷非常挑剔，这个问题看起来不再那么做作了。性能提示非常相关。对你来说，做Euler项目也很有好处。我相信空间复杂性，而不是时间简单性是使用此算法的上网本的限制因素空间。您可能希望在1亿个块中分割素数，以减少在任何给定时间使用的空间。此外，为了减少空间，您可能希望使用字节数组和位标志，而不是布尔值。位屏蔽可能更复杂一些，但它可能会将您的空间使用量减少8倍。您只需要对其进行筛选对于B的sqrt的素数，不是所有A的素数。这是一个巨大的杀伤力。不完全是。上面的代码说：
对于p在A的sqrt（B）
。但是你只需要
sqrt（B）
。这可能比
A
小很多，对于
A的最合理的值，
B
（范围通常比较窄）。如果是，第一个循环将超时工作，第二个循环根本不做任何工作。此外，您只需要在第二个循环中从
p*p
开始，而不是从
2*p
开始，并在两个循环中使用
2*p
而不是
p
作为步骤，对于除第一个外的所有素数（
2
）。
def extend_erathostene(A, B, prime_up_to_A):
    sieve = [ True ]* (B-A)
    for p in prime_up_to_A:
        # first multiple of p greater than A
        m0 = ((A+p-1)/p)*p
        for m in range( m0, B, p):
            sieve[m-A] = False
    limit = int(ceil(sqrt(B)))
    for p in range(A,limit+1):
        if sieve[p-A]:
            for m in range(p*2, B, p):
                sieve[m-A] = False 
    return prime_up_to_A + [ A+c for (c, isprime) in enumerate(sieve) if isprime]