Самый быстрый способ перечислить все простые числа ниже N

связанный вопрос(дело с генераторами простых чисел и включая контрольные показатели):
ускорить операции bitstring / bit в Python?

для версий python 3 с использованием bytearray & compress см.: https://stackoverflow.com/a/46635266/350331

быстрее и больше памяти мудрый чистый код Python:

def primes(n):
    """ Returns  a list of primes < n """
    sieve = [True] * n
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i]:
            sieve[i*i::2*i]=[False]*((n-i*i-1)/(2*i)+1)
    return [2] + [i for i in xrange(3,n,2) if sieve[i]]

или, начиная с половины решето

def primes1(n):
    """ Returns  a list of primes < n """
    sieve = [True] * (n/2)
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i/2]:
            sieve[i*i/2::i] = [False] * ((n-i*i-1)/(2*i)+1)
    return [2] + [2*i+1 for i in xrange(1,n/2) if sieve[i]]

быстрее и больше памяти мудрый numpy код:

import numpy
def primesfrom3to(n):
    """ Returns a array of primes, 3 <= p < n """
    sieve = numpy.ones(n/2, dtype=numpy.bool)
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i/2]:
            sieve[i*i/2::i] = False
    return 2*numpy.nonzero(sieve)[0][1::]+1

более быстрая вариация, начинающаяся с трети сита:

import numpy
def primesfrom2to(n):
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = numpy.ones(n/3 + (n%6==2), dtype=numpy.bool)
    for i in xrange(1,int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[       k*k/3     ::2*k] = False
            sieve[k*(k-2*(i&1)+4)/3::2*k] = False
    return numpy.r_[2,3,((3*numpy.nonzero(sieve)[0][1:]+1)|1)]

a (жесткий код) pure-python версия вышеуказанного кода будет:

def primes2(n):
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    n, correction = n-n%6+6, 2-(n%6>1)
    sieve = [True] * (n/3)
    for i in xrange(1,int(n**0.5)/3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      k*k/3      ::2*k] = [False] * ((n/6-k*k/6-1)/k+1)
        sieve[k*(k-2*(i&1)+4)/3::2*k] = [False] * ((n/6-k*(k-2*(i&1)+4)/6-1)/k+1)
    return [2,3] + [3*i+1|1 for i in xrange(1,n/3-correction) if sieve[i]]

к сожалению, pure-python не принимает более простой и быстрый способ выполнения задания numpy и вызова len () внутри цикла, как в [False]*len(sieve[((k*k)/3)::2*k]) слишком медленно. Поэтому мне пришлось импровизировать, чтобы исправить ввод (и избежать больше математики) и сделать некоторую экстремальную (и болезненную) математическую магию.
Лично я так думаю. жаль, что numpy(который так широко используется) не является частью стандартной библиотеки python (через 2 года после выпуска python 3 и без совместимости numpy), и что улучшения в синтаксисе и скорости, похоже, полностью игнорируются разработчиками python.

есть довольно аккуратный образец из Поваренной книги Python здесь -- самая быстрая версия, предлагаемая по этому URL-адресу:

import itertools
def erat2( ):
    D = {  }
    yield 2
    for q in itertools.islice(itertools.count(3), 0, None, 2):
        p = D.pop(q, None)
        if p is None:
            D[q*q] = q
            yield q
        else:
            x = p + q
            while x in D or not (x&1):
                x += p
            D[x] = p

Так, что бы дать

def get_primes_erat(n):
  return list(itertools.takewhile(lambda p: p<n, erat2()))

измерение в командной строке оболочки (как я предпочитаю делать) с этим кодом в pri.py я замечаю:

$ python2.5 -mtimeit -s'import pri' 'pri.get_primes(1000000)'
10 loops, best of 3: 1.69 sec per loop
$ python2.5 -mtimeit -s'import pri' 'pri.get_primes_erat(1000000)'
10 loops, best of 3: 673 msec per loop

таким образом, похоже, что решение поваренной книги в два раза быстрее.

используя сито Сундарама, Я думаю, что я побил рекорд pure-Python:

def sundaram3(max_n):
    numbers = range(3, max_n+1, 2)
    half = (max_n)//2
    initial = 4

    for step in xrange(3, max_n+1, 2):
        for i in xrange(initial, half, step):
            numbers[i-1] = 0
        initial += 2*(step+1)

        if initial > half:
            return [2] + filter(None, numbers)

сравнение:

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.get_primes_erat(1000000)"
10 loops, best of 3: 710 msec per loop

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.daniel_sieve_2(1000000)"
10 loops, best of 3: 435 msec per loop

C:\USERS>python -m timeit -n10 -s "import get_primes" "get_primes.sundaram3(1000000)"
10 loops, best of 3: 327 msec per loop

алгоритм быстрый, но у него есть серьезный недостаток:

>>> sorted(get_primes(530))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,
167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,
257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,
449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 527, 529]
>>> 17*31
527
>>> 23*23
529

вы предполагаете, что numbers.pop() возвращает наименьшее число в наборе, но это не гарантируется на всех. Наборы неупорядочены и pop() удаляет и возвращает элемент произвольные элемент, поэтому его нельзя использовать для выбора следующего простого из оставшихся чисел.

на истинно самым быстрым решением с достаточно большим N было бы загрузить предварительно рассчитанный список простых чисел, сохраните его как кортеж и сделайте что-то вроде:

for pos,i in enumerate(primes):
    if i > N:
        print primes[:pos]

Если N > primes[-1] только затем вычислить более простых и сохранить новый список в коде, так что в следующий раз столь же быстро.

всегда думайте нестандартно.

Если вы не хотите изобретать колесо, вы можете установить символическую библиотеку математики sympy (да, это совместимый Python 3)

pip install sympy

и с помощью primerange функции

from sympy import sieve
primes = list(sieve.primerange(1, 10**6))

полезно написать свой собственный код простого поиска, но также полезно иметь под рукой быструю надежную библиотеку. Я написал обертку вокруг C++ библиотека primesieve, назвав его primesieve-python

попробуй pip install primesieve

import primesieve
primes = primesieve.generate_primes(10**8)

мне было бы интересно увидеть скорость по сравнению.

Если вы принимаете itertools, но не numpy, вот адаптация rwh_primes2 для Python 3, которая работает примерно в два раза быстрее на моей машине. Единственное существенное изменение-использование bytearray вместо списка для логического и использование compress вместо понимания списка для создания окончательного списка. (Я бы добавил Это как комментарий, как moarningsun, если бы мог.)

import itertools
izip = itertools.zip_longest
chain = itertools.chain.from_iterable
compress = itertools.compress
def rwh_primes2_python3(n):
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    zero = bytearray([False])
    size = n//3 + (n % 6 == 2)
    sieve = bytearray([True]) * size
    sieve[0] = False
    for i in range(int(n**0.5)//3+1):
      if sieve[i]:
        k=3*i+1|1
        start = (k*k+4*k-2*k*(i&1))//3
        sieve[(k*k)//3::2*k]=zero*((size - (k*k)//3 - 1) // (2 * k) + 1)
        sieve[  start ::2*k]=zero*((size -   start  - 1) // (2 * k) + 1)
    ans = [2,3]
    poss = chain(izip(*[range(i, n, 6) for i in (1,5)]))
    ans.extend(compress(poss, sieve))
    return ans

для сравнения:

>>> timeit.timeit('primes.rwh_primes2(10**6)', setup='import primes', number=1)
0.0652179726976101
>>> timeit.timeit('primes.rwh_primes2_python3(10**6)', setup='import primes', number=1)
0.03267321276325674

и

>>> timeit.timeit('primes.rwh_primes2(10**8)', setup='import primes', number=1)
6.394284538007014
>>> timeit.timeit('primes.rwh_primes2_python3(10**8)', setup='import primes', number=1)
3.833829450302801

детерминированная реализация теста примитивности Миллера-Рабина при предположении, что N

import sys
import random

def miller_rabin_pass(a, n):
    d = n - 1
    s = 0
    while d % 2 == 0:
        d >>= 1
        s += 1

    a_to_power = pow(a, d, n)
    if a_to_power == 1:
        return True
    for i in xrange(s-1):
        if a_to_power == n - 1:
            return True
        a_to_power = (a_to_power * a_to_power) % n
    return a_to_power == n - 1


def miller_rabin(n):
    for a in [2, 3, 37, 73]:
      if not miller_rabin_pass(a, n):
        return False
    return True


n = int(sys.argv[1])
primes = [2]
for p in range(3,n,2):
  if miller_rabin(p):
    primes.append(p)
print len(primes)

согласно статье в Википедии (http://en.wikipedia.org/wiki/Miller-Rabin_primality_test) тестирование N

и я адаптировал исходный код из вероятностной реализации оригинального теста Миллера-Рабина, найденного здесь: http://en.literateprograms.org/Miller-Rabin_primality_test_ (Python)

Если у вас есть контроль над N, самый быстрый способ перечислить все простые числа-предварительно вычислить их. Серьезно. Precomputing - это способ оптимизации, который упускается из виду.

вот код, который я использую для генерации простых чисел в Python:

$ python -mtimeit -s'import sieve' 'sieve.sieve(1000000)' 
10 loops, best of 3: 445 msec per loop
$ cat sieve.py
from math import sqrt

def sieve(size):
 prime=[True]*size
 rng=xrange
 limit=int(sqrt(size))

 for i in rng(3,limit+1,+2):
  if prime[i]:
   prime[i*i::+i]=[False]*len(prime[i*i::+i])

 return [2]+[i for i in rng(3,size,+2) if prime[i]]

if __name__=='__main__':
 print sieve(100)

он не может конкурировать с более быстрыми решениями, размещенными здесь, но, по крайней мере, это чистый python.

Спасибо за размещение этого вопроса. Сегодня я действительно многому научился.

для самого быстрого кода решение numpy является лучшим. По чисто академическим причинам, однако, я публикую свою версию pure python, которая немного меньше, чем на 50% быстрее, чем версия поваренной книги, опубликованная выше. Поскольку я делаю весь список в памяти, вам нужно достаточно места, чтобы вместить все, но он, кажется, довольно хорошо масштабируется.

def daniel_sieve_2(maxNumber):
    """
    Given a number, returns all numbers less than or equal to
    that number which are prime.
    """
    allNumbers = range(3, maxNumber+1, 2)
    for mIndex, number in enumerate(xrange(3, maxNumber+1, 2)):
        if allNumbers[mIndex] == 0:
            continue
        # now set all multiples to 0
        for index in xrange(mIndex+number, (maxNumber-3)/2+1, number):
            allNumbers[index] = 0
    return [2] + filter(lambda n: n!=0, allNumbers)

результаты:

>>>mine = timeit.Timer("daniel_sieve_2(1000000)",
...                    "from sieves import daniel_sieve_2")
>>>prev = timeit.Timer("get_primes_erat(1000000)",
...                    "from sieves import get_primes_erat")
>>>print "Mine: {0:0.4f} ms".format(min(mine.repeat(3, 1))*1000)
Mine: 428.9446 ms
>>>print "Previous Best {0:0.4f} ms".format(min(prev.repeat(3, 1))*1000)
Previous Best 621.3581 ms

немного другая реализация половины сита с использованием Numpy:

http://rebrained.com/?p=458

import math
import numpy
def prime6(upto):
    primes=numpy.arange(3,upto+1,2)
    isprime=numpy.ones((upto-1)/2,dtype=bool)
    for factor in primes[:int(math.sqrt(upto))]:
        if isprime[(factor-2)/2]: isprime[(factor*3-2)/2:(upto-1)/2:factor]=0
    return numpy.insert(primes[isprime],0,2)

может ли кто-нибудь сравнить это с другими таймингами? На моей машине это кажется довольно сопоставимым с другим Numpy half-sieve.

все написано и проверено. Поэтому нет необходимости изобретать колесо.

python -m timeit -r10 -s"from sympy import sieve" "primes = list(sieve.primerange(1, 10**6))"

дает нам рекорд12.2 мсек!

10 loops, best of 10: 12.2 msec per loop

если это не достаточно быстро, вы можете попробовать PyPy:

pypy -m timeit -r10 -s"from sympy import sieve" "primes = list(sieve.primerange(1, 10**6))"

что приводит к:

10 loops, best of 10: 2.03 msec per loop

ответ с 247 up-votes перечисляет 15.9 ms для лучшего решения. Сравните это!!!

вот две обновленные (pure Python 3.6) версии одной из самых быстрых функций,

from itertools import compress

def rwh_primes1v1(n):
    """ Returns  a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2)
    for i in range(3,int(n**0.5)+1,2):
        if sieve[i//2]:
            sieve[i*i//2::i] = bytearray((n-i*i-1)//(2*i)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

def rwh_primes1v2(n):
    """ Returns a list of primes < n for n > 2 """
    sieve = bytearray([True]) * (n//2+1)
    for i in range(1,int(n**0.5)//2+1):
        if sieve[i]:
            sieve[2*i*(i+1)::2*i+1] = bytearray((n//2-2*i*(i+1))//(2*i+1)+1)
    return [2,*compress(range(3,n,2), sieve[1:])]

первый раз с использованием python, поэтому некоторые из методов, которые я использую в этом, могут показаться немного громоздкими. Я просто прямо преобразовал свой код C++ в python, и это то, что у меня есть (хотя и немного slowww в python)

#!/usr/bin/env python
import time

def GetPrimes(n):

    Sieve = [1 for x in xrange(n)]

    Done = False
    w = 3

    while not Done:

        for q in xrange (3, n, 2):
            Prod = w*q
            if Prod < n:
                Sieve[Prod] = 0
            else:
                break

        if w > (n/2):
            Done = True
        w += 2

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

pythonw Primes.py

нашли 664579 primes в 12.799119 секунд!

#!/usr/bin/env python
import time

def GetPrimes2(n):

    Sieve = [1 for x in xrange(n)]

    for q in xrange (3, n, 2):
        k = q
        for y in xrange(k*3, n, k*2):
            Sieve[y] = 0

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes2(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

pythonw Primes2.py

нашли 664579 primes в 10.230172 секунд!

#!/usr/bin/env python
import time

def GetPrimes3(n):

    Sieve = [1 for x in xrange(n)]

    for q in xrange (3, n, 2):
        k = q
        for y in xrange(k*k, n, k << 1):
            Sieve[y] = 0

    return Sieve



start = time.clock()

d = 10000000
Primes = GetPrimes3(d)

count = 1 #This is for 2

for x in xrange (3, d, 2):
    if Primes[x]:
        count+=1

elapsed = (time.clock() - start)
print "\nFound", count, "primes in", elapsed, "seconds!\n"

python Primes2.py

нашли 664579 primes в 7.113776 секунд!

Я знаю, что конкурс будет закрыт в течение нескольких лет. ...

тем не менее, это мое предложение для чистого простого сита python, основанного на опущении кратных 2, 3 и 5, используя соответствующие шаги при обработке сита вперед. Тем не менее, это на самом деле медленнее для N

10^6

$ python-mtimeit-s"импорт primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (1000000)" 10 петель, лучше всего 3: 46.7 msec на петлю

для сравнения:$ python-mtimeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (1000000)" 10 петель, лучшее из 3: 43.2 мсек на каждую петлю для сравнения: $ python-m timeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes2 (1000000)" 10 петель, лучшее из 3: 34.5 мс за цикл

10^7

$ python-mtimeit-s"импорт primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq(10000000)" 10 петель, лучше всего 3: 530 МС на петлю

для сравнения:$ python-mtimeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (10000000)" 10 петель, лучшее из 3: 494 мсек на каждую петлю для сравнения: $ python-m timeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes2 (10000000)" 10 петель, лучший из 3: Триста семьдесят пять МС за цикл

10^8

$ python-mtimeit-s"импорт primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq(100000000)" 10 петель, лучше всего 3: 5.55 сек на петлю

для сравнения: $ python-mtimeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (100000000)" 10 петель, лучший из 3: 5.33 сек на цикл для сравнения: $ python-m timeit-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes2 (100000000)" 10 циклов, лучше 3: 3.95 сек на цикл

10^9

$ python-mtimeit-s"импорт primeSieveSpeedComp" "primeSieveSpeedComp.primeSieveSeq (1000000000)" 10 циклов, лучше 3: 61.2 сек за цикл

для сравнения: $ python-mtimeit-n 3-s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes1 (1000000000) " 3 петли, лучший из 3: 97.8 сек на цикл

для сравнения: $ python-m timeit - s " импорт primeSieveSpeedComp" "primeSieveSpeedComp.rwh_primes2 (1000000000) " 10 циклов, лучший из 3: 41.9 сек за цикл

вы можете скопировать код ниже в ubuntus primeSieveSpeedComp, чтобы просмотреть эти тесты.

def primeSieveSeq(MAX_Int):
    if MAX_Int > 5*10**8:
        import ctypes
        int16Array = ctypes.c_ushort * (MAX_Int >> 1)
        sieve = int16Array()
        #print 'uses ctypes "unsigned short int Array"'
    else:
        sieve = (MAX_Int >> 1) * [False]
        #print 'uses python list() of long long int'
    if MAX_Int < 10**8:
        sieve[4::3] = [True]*((MAX_Int - 8)/6+1)
        sieve[12::5] = [True]*((MAX_Int - 24)/10+1)
    r = [2, 3, 5]
    n = 0
    for i in xrange(int(MAX_Int**0.5)/30+1):
        n += 3
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 2
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 3
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
        n += 1
        if not sieve[n]:
            n2 = (n << 1) + 1
            r.append(n2)
            n2q = (n2**2) >> 1
            sieve[n2q::n2] = [True]*(((MAX_Int >> 1) - n2q - 1) / n2 + 1)
    if MAX_Int < 10**8:
        return [2, 3, 5]+[(p << 1) + 1 for p in [n for n in xrange(3, MAX_Int >> 1) if not sieve[n]]]
    n = n >> 1
    try:
        for i in xrange((MAX_Int-2*n)/30 + 1):
            n += 3
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 2
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 3
            if not sieve[n]:
                r.append((n << 1) + 1)
            n += 1
            if not sieve[n]:
                r.append((n << 1) + 1)
    except:
        pass
    return r

я протестировал некоторые unutbu это, я вычислил его с числом голодных миллионов

победителями являются функции, использующие библиотеку numpy,

Примечание: было бы также интересно сделать тест памяти :)

пример кода

полный код в моем репозитории github

#!/usr/bin/env python

import lib
import timeit
import sys
import math
import datetime

import prettyplotlib as ppl
import numpy as np

import matplotlib.pyplot as plt
from prettyplotlib import brewer2mpl

primenumbers_gen = [
    'sieveOfEratosthenes',
    'ambi_sieve',
    'ambi_sieve_plain',
    'sundaram3',
    'sieve_wheel_30',
    'primesfrom3to',
    'primesfrom2to',
    'rwh_primes',
    'rwh_primes1',
    'rwh_primes2',
]

def human_format(num):
    # https://stackoverflow.com/questions/579310/formatting-long-numbers-as-strings-in-python?answertab=active#tab-top
    magnitude = 0
    while abs(num) >= 1000:
        magnitude += 1
        num /= 1000.0
    # add more suffixes if you need them
    return '%.2f%s' % (num, ['', 'K', 'M', 'G', 'T', 'P'][magnitude])


if __name__=='__main__':

    # Vars
    n = 10000000 # number itereration generator
    nbcol = 5 # For decompose prime number generator
    nb_benchloop = 3 # Eliminate false positive value during the test (bench average time)
    datetimeformat = '%Y-%m-%d %H:%M:%S.%f'
    config = 'from __main__ import n; import lib'
    primenumbers_gen = {
        'sieveOfEratosthenes': {'color': 'b'},
        'ambi_sieve': {'color': 'b'},
        'ambi_sieve_plain': {'color': 'b'},
         'sundaram3': {'color': 'b'},
        'sieve_wheel_30': {'color': 'b'},
# # #        'primesfrom2to': {'color': 'b'},
        'primesfrom3to': {'color': 'b'},
        # 'rwh_primes': {'color': 'b'},
        # 'rwh_primes1': {'color': 'b'},
        'rwh_primes2': {'color': 'b'},
    }


    # Get n in command line
    if len(sys.argv)>1:
        n = int(sys.argv[1])

    step = int(math.ceil(n / float(nbcol)))
    nbs = np.array([i * step for i in range(1, int(nbcol) + 1)])
    set2 = brewer2mpl.get_map('Paired', 'qualitative', 12).mpl_colors

    print datetime.datetime.now().strftime(datetimeformat)
    print("Compute prime number to %(n)s" % locals())
    print("")

    results = dict()
    for pgen in primenumbers_gen:
        results[pgen] = dict()
        benchtimes = list()
        for n in nbs:
            t = timeit.Timer("lib.%(pgen)s(n)" % locals(), setup=config)
            execute_times = t.repeat(repeat=nb_benchloop,number=1)
            benchtime = np.mean(execute_times)
            benchtimes.append(benchtime)
        results[pgen] = {'benchtimes':np.array(benchtimes)}

fig, ax = plt.subplots(1)
plt.ylabel('Computation time (in second)')
plt.xlabel('Numbers computed')
i = 0
for pgen in primenumbers_gen:

    bench = results[pgen]['benchtimes']
    avgs = np.divide(bench,nbs)
    avg = np.average(bench, weights=nbs)

    # Compute linear regression
    A = np.vstack([nbs, np.ones(len(nbs))]).T
    a, b = np.linalg.lstsq(A, nbs*avgs)[0]

    # Plot
    i += 1
    #label="%(pgen)s" % locals()
    #ppl.plot(nbs, nbs*avgs, label=label, lw=1, linestyle='--', color=set2[i % 12])
    label="%(pgen)s avg" % locals()
    ppl.plot(nbs, a * nbs + b, label=label, lw=2, color=set2[i % 12])
print datetime.datetime.now().strftime(datetimeformat)

ppl.legend(ax, loc='upper left', ncol=4)

# Change x axis label
ax.get_xaxis().get_major_formatter().set_scientific(False)
fig.canvas.draw()
labels = [human_format(int(item.get_text())) for item in ax.get_xticklabels()]

ax.set_xticklabels(labels)
ax = plt.gca()

plt.show()

Для Python 3

def rwh_primes2(n):
    correction = (n%6>1)
    n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]
    sieve = [True] * (n//3)
    sieve[0] = False
    for i in range(int(n**0.5)//3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      ((k*k)//3)      ::2*k]=[False]*((n//6-(k*k)//6-1)//k+1)
        sieve[(k*k+4*k-2*k*(i&1))//3::2*k]=[False]*((n//6-(k*k+4*k-2*k*(i&1))//6-1)//k+1)
    return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]

Я предполагаю, что быстрый из всех способов-это жесткий код числа в коде.

Так почему бы просто не написать медленный сценарий, который генерирует другой исходный файл, в котором есть все номера, а затем импортировать этот исходный файл при запуске фактической программы.

конечно, это работает, только если вы знаете верхнюю границу N во время компиляции, но, таким образом, это касается (почти) всех проблем проекта Эйлера.

PS: Я могу ошибаться, хотя IFF разбор источника с жесткими проводными простыми числами медленнее, чем их вычисление в первую очередь, но, насколько я знаю, Python запускается из compiled .pyc файлы, поэтому чтение двоичного массива со всеми простыми числами до N должно быть чертовски быстрым в этом случае.

извините за беспокойство, но erat2 () имеет серьезный недостаток в алгоритме.

при поиске следующего композита нам нужно проверить только нечетные числа. q, p оба нечетны; тогда q+p четно и не нуждается в проверке, но q+2*p всегда нечетно. Это устраняет тест "если даже" в состоянии цикла while и экономит около 30% времени выполнения.

пока мы на нем: вместо элегантного "D. pop (q, None)" get и delete используется метод " если q в D: p=D[q], del D[q]", который вдвое быстрее! По крайней мере, на моей машине (P3-1Ghz). Поэтому я предлагаю эту реализацию этого умного алгоритма:

def erat3( ):
    from itertools import islice, count

    # q is the running integer that's checked for primeness.
    # yield 2 and no other even number thereafter
    yield 2
    D = {}
    # no need to mark D[4] as we will test odd numbers only
    for q in islice(count(3),0,None,2):
        if q in D:                  #  is composite
            p = D[q]
            del D[q]
            # q is composite. p=D[q] is the first prime that
            # divides it. Since we've reached q, we no longer
            # need it in the map, but we'll mark the next
            # multiple of its witnesses to prepare for larger
            # numbers.
            x = q + p+p        # next odd(!) multiple
            while x in D:      # skip composites
                x += p+p
            D[x] = p
        else:                  # is prime
            # q is a new prime.
            # Yield it and mark its first multiple that isn't
            # already marked in previous iterations.
            D[q*q] = q
            yield q

самый быстрый метод, который я пробовал до сих пор, основан на поваренная книга Python erat2 функция:

import itertools as it
def erat2a( ):
    D = {  }
    yield 2
    for q in it.islice(it.count(3), 0, None, 2):
        p = D.pop(q, None)
        if p is None:
            D[q*q] = q
            yield q
        else:
            x = q + 2*p
            while x in D:
                x += 2*p
            D[x] = p

посмотреть этой ответ для объяснения ускорения.

Я могу опоздать на вечеринку, но для этого мне придется добавить свой собственный код. Он использует приблизительно n / 2 в пространстве, потому что нам не нужно хранить четные числа, и я также использую модуль bitarray python, что еще больше сокращает потребление памяти и позволяет вычислять все простые числа до 1,000,000,000

from bitarray import bitarray
def primes_to(n):
    size = n//2
    sieve = bitarray(size)
    sieve.setall(1)
    limit = int(n**0.5)
    for i in range(1,limit):
        if sieve[i]:
            val = 2*i+1
            sieve[(i+i*val)::val] = 0
    return [2] + [2*i+1 for i, v in enumerate(sieve) if v and i > 0]

python -m timeit -n10 -s "import euler" "euler.primes_to(1000000000)"
10 loops, best of 3: 46.5 sec per loop

Это было запущено на 64bit 2.4 GHZ MAC OSX 10.8.3

Я собрал несколько простых чисел решето с течением времени. Самый быстрый на моем компьютере это:

from time import time
# 175 ms for all the primes up to the value 10**6
def primes_sieve(limit):
    a = [True] * limit
    a[0] = a[1] = False
    #a[2] = True
    for n in xrange(4, limit, 2):
        a[n] = False
    root_limit = int(limit**.5)+1
    for i in xrange(3,root_limit):
        if a[i]:
            for n in xrange(i*i, limit, 2*i):
                a[n] = False
    return a

LIMIT = 10**6
s=time()
primes = primes_sieve(LIMIT)
print time()-s

Я медленно отвечаю на этот вопрос, но это казалось забавным упражнением. Я использую numpy, который может быть обманом, и я сомневаюсь, что этот метод является самым быстрым, но он должен быть ясным. Он просеивает логический массив, ссылающийся только на его индексы, и извлекает простые числа из индексов всех истинных значений. Модуль не требуется.

import numpy as np
def ajs_primes3a(upto):
    mat = np.ones((upto), dtype=bool)
    mat[0] = False
    mat[1] = False
    mat[4::2] = False
    for idx in range(3, int(upto ** 0.5)+1, 2):
        mat[idx*2::idx] = False
    return np.where(mat == True)[0]

вот интересный метод генерации простых чисел (но не самый эффективный) с использованием списка Python:

noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
primes = [x for x in range(2, 50) if x not in noprimes]

вы можете найти пример и некоторые разъяснения прав здесь

В общем, если вам нужно быстрое вычисление чисел, python-не лучший выбор. Сегодня существует множество более быстрых (и сложных) алгоритмов. Например, на моем компьютере я получил 2.2 секунды для вашего кода, с Mathematica я получил 0.088005.

прежде всего: вам нужен набор?

это элегантное и простое решение для поиска простых чисел с помощью сохраненного списка. Начинается с 4 переменных, вам нужно проверить только нечетные простые числа для делителей, и вам нужно проверить только до половины того, какое число вы тестируете как простое (нет смысла проверять, делятся ли 9, 11, 13 на 17). Он проверяет ранее сохраненные простые числа как делители.`

    # Program to calculate Primes
 primes = [1,3,5,7]
for n in range(9,100000,2):
    for x in range(1,(len(primes)/2)):
        if n % primes[x] == 0:
            break
    else:
        primes.append(n)
print primes

Так вы можете сравнивать с другими.

# You have to list primes upto n
nums = xrange(2, n)
for i in range(2, 10):
    nums = filter(lambda s: s==i or s%i, nums)
print nums

Так Просто...