我使用Sieve of Eratosthenes和Python 3.1编写了素数生成器。代码在ideone.com上以0.32秒正确且正常地运行，以生成高达1,000,000的素数。
# from bitstring import BitString
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
flags = [False, False] + [True] * (limit - 2)
# flags = BitString(limit)
# Step through all the odd numbers
for i in range(3, limit, 2):
if flags[i] is False:
# if flags[i] is True:
continue
yield i
# Exclude further multiples of the current prime number
if i <= sub_limit:
for j in range(i*3, limit, i<<1):
flags[j] = False
# flags[j] = True
问题是，当我尝试生成高达1,000,000,000的数字时，内存不足。
flags = [False, False] + [True] * (limit - 2)
MemoryError
可以想象，在Python中分配10亿个布尔值（ 1个字节 4或8个字节（请参阅注释））实际上是不可行的，所以我查看了bitstring。我想，每个标志使用1位将更加节省内存。然而，该程序的性能急剧下降 - 运行时间为24秒，素数高达1,000,000。这可能是由于bitstring的内部实现。
您可以评论/取消注释这三行，以查看我更改为使用BitString的内容，作为上面的代码段。
我的问题是，有没有办法加速我的程序，有或没有位串？
编辑：请在发布前自行测试代码。我自然不能接受比现有代码慢的答案。
再次修改：
答案 0 :(得分：34)
您的版本有一些小优化。通过反转True和False的角色，您可以将“if flags[i] is False:”更改为“if flags[i]:”。第二个range语句的起始值可以是i*i，而不是i*3。您的原始版本在我的系统上需要0.166秒。通过这些更改，我的系统下面的版本需要0.156秒。
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
flags = [True, True] + [False] * (limit - 2)
# Step through all the odd numbers
for i in range(3, limit, 2):
if flags[i]:
continue
yield i
# Exclude further multiples of the current prime number
if i <= sub_limit:
for j in range(i*i, limit, i<<1):
flags[j] = True
但这对你的记忆问题没有帮助。
进入C扩展世界，我使用了gmpy的开发版本。 （免责声明：我是维护者之一。）开发版本称为gmpy2，支持名为xmpz的可变整数。使用gmpy2和以下代码，我的运行时间为0.140秒。限制为1,000,000,000的运行时间为158秒。
import gmpy2
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
# Actual number is 2*bit_position + 1.
oddnums = gmpy2.xmpz(1)
current = 0
while True:
current += 1
current = oddnums.bit_scan0(current)
prime = 2 * current + 1
if prime > limit:
break
yield prime
# Exclude further multiples of the current prime number
if prime <= sub_limit:
for j in range(2*current*(current+1), limit>>1, prime):
oddnums.bit_set(j)
推动优化并牺牲清晰度，使用以下代码获得0.107和123秒的运行时间：
import gmpy2
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
# Actual number is 2*bit_position + 1.
oddnums = gmpy2.xmpz(1)
f_set = oddnums.bit_set
f_scan0 = oddnums.bit_scan0
current = 0
while True:
current += 1
current = f_scan0(current)
prime = 2 * current + 1
if prime > limit:
break
yield prime
# Exclude further multiples of the current prime number
if prime <= sub_limit:
list(map(f_set,range(2*current*(current+1), limit>>1, prime)))
编辑：根据此练习，我修改了gmpy2以接受xmpz.bit_set(iterator)。使用以下代码，所有素数少于1,000,000,000的运行时间对于Python 2.7为56秒，对于Python 3.2为74秒。 （如评论中所述，xrange比range更快。）
import gmpy2
try:
range = xrange
except NameError:
pass
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
oddnums = gmpy2.xmpz(1)
f_scan0 = oddnums.bit_scan0
current = 0
while True:
current += 1
current = f_scan0(current)
prime = 2 * current + 1
if prime > limit:
break
yield prime
if prime <= sub_limit:
oddnums.bit_set(iter(range(2*current*(current+1), limit>>1, prime)))
编辑＃2：再试一次！我修改了gmpy2以接受xmpz.bit_set(slice)。使用以下代码，Python 2.7和Python 3.2的所有质数小于1,000,000,000的运行时间约为40秒。
from __future__ import print_function
import time
import gmpy2
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
yield 2
sub_limit = int(limit**0.5)
flags = gmpy2.xmpz(1)
# pre-allocate the total length
flags.bit_set((limit>>1)+1)
f_scan0 = flags.bit_scan0
current = 0
while True:
current += 1
current = f_scan0(current)
prime = 2 * current + 1
if prime > limit:
break
yield prime
if prime <= sub_limit:
flags.bit_set(slice(2*current*(current+1), limit>>1, prime))
start = time.time()
result = list(prime_numbers(1000000000))
print(time.time() - start)
编辑＃3：我已经更新了gmpy2以正确支持xmpz位级别的切片。性能没有变化，但是API非常好。我做了一点调整，我的时间缩短了大约37秒。 （请参阅编辑＃4以了解gmpy2 2.0.0b1中的更改。）
from __future__ import print_function
import time
import gmpy2
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
sub_limit = int(limit**0.5)
flags = gmpy2.xmpz(1)
flags[(limit>>1)+1] = True
f_scan0 = flags.bit_scan0
current = 0
prime = 2
while prime <= sub_limit:
yield prime
current += 1
current = f_scan0(current)
prime = 2 * current + 1
flags[2*current*(current+1):limit>>1:prime] = True
while prime <= limit:
yield prime
current += 1
current = f_scan0(current)
prime = 2 * current + 1
start = time.time()
result = list(prime_numbers(1000000000))
print(time.time() - start)
编辑＃4：我在gmpy2 2.0.0b1中做了一些改动，打破了前面的例子。 gmpy2不再将True视为提供1位无限来源的特殊值。应该使用-1代替。
from __future__ import print_function
import time
import gmpy2
def prime_numbers(limit=1000000):
'''Prime number generator. Yields the series
2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ...
using Sieve of Eratosthenes.
'''
sub_limit = int(limit**0.5)
flags = gmpy2.xmpz(1)
flags[(limit>>1)+1] = 1
f_scan0 = flags.bit_scan0
current = 0
prime = 2
while prime <= sub_limit:
yield prime
current += 1
current = f_scan0(current)
prime = 2 * current + 1
flags[2*current*(current+1):limit>>1:prime] = -1
while prime <= limit:
yield prime
current += 1
current = f_scan0(current)
prime = 2 * current + 1
start = time.time()
result = list(prime_numbers(1000000000))
print(time.time() - start)
编辑＃5：我对gmpy2 2.0.0b2做了一些改进。您现在可以迭代所有已设置或清除的位。运行时间提高了约30％。
from __future__ import print_function
import time
import gmpy2
def sieve(limit=1000000):
'''Returns a generator that yields the prime numbers up to limit.'''
# Increment by 1 to account for the fact that slices do not include
# the last index value but we do want to include the last value for
# calculating a list of primes.
sieve_limit = gmpy2.isqrt(limit) + 1
limit += 1
# Mark bit positions 0 and 1 as not prime.
bitmap = gmpy2.xmpz(3)
# Process 2 separately. This allows us to use p+p for the step size
# when sieving the remaining primes.
bitmap[4 : limit : 2] = -1
# Sieve the remaining primes.
for p in bitmap.iter_clear(3, sieve_limit):
bitmap[p*p : limit : p+p] = -1
return bitmap.iter_clear(2, limit)
if __name__ == "__main__":
start = time.time()
result = list(sieve(1000000000))
print(time.time() - start)
print(len(result))
答案 1 :(得分：8)
好的，所以这是我的第二个答案，但由于速度至关重要，我认为我必须提到bitarray模块 - 即使它是bitstring的克星:)。它非常适合这种情况，因为它不仅是一个C扩展（并且比纯Python更有希望），但它也支持切片分配。但它尚不适用于Python 3。
我甚至没有尝试优化它，我只是重写了bitstring版本。在我的机器上，我得到0.16秒的素数低于一百万。
十亿，它运行得非常好，并在2分31秒内完成。
import bitarray
def prime_bitarray(limit=1000000):
yield 2
flags = bitarray.bitarray(limit)
flags.setall(False)
sub_limit = int(limit**0.5)
for i in xrange(3, limit, 2):
if not flags[i]:
yield i
if i <= sub_limit:
flags[3*i:limit:i*2] = True
答案 2 :(得分：8)
好的，这是一个（近乎完整的）全面的基准测试我今晚已经完成，看看哪个代码运行速度最快。希望有人会发现这个列表很有用。我省略了在我的机器上完成任何需要超过30秒的事情。
我要感谢所有投入的人。我从你的努力中获得了很多洞察力，我希望你也有。
我的机器：AMD ZM-86,2.40 Ghz双核，4GB内存。这是一台HP Touchsmart Tx2笔记本电脑。请注意，虽然我可能已链接到pastebin，但我在自己的计算机上对以下所有内容进行了基准测试。
一旦我能够构建它，我将添加gmpy2基准。
所有基准测试都在Python 2.6 x86中进行测试