Python 素数位置搜索结束规模过大怎么办？

这是一个检查数字是否为素数的函数

def isprime(number):
    counter = 0
    for n in range(1,number+1):
        if number % n == 0:
            counter += 1

    if counter == 2:
        return True

my_list=[]
n1=1
而len（my_list）快速素性测试是一个巨大的课题

通常足够快的是检查一个数字是否可以被2或3整除，然后检查从4到该数字平方根的所有可能的除数

那么，试试这个：

my_list = []
n1 = 1
while len(my_list) <= 10000:
    n1 += 1
    if isprime(n1) is True:
        my_list.append(n1)


print(my_list[-1])

对于需要求解的大小的数字，通过试除法确定素性就足够了。这是一个使用2,3,5轮的简单素性检查器，速度大约是Yakov Dan发布的朴素素性检查器的两倍：

def is_prime(n):
    if n == 1:
        return False
    if n == 2:
        return True
    if n == 3:
        return True
    if n % 2 == 0
        return False
    if n % 3 == 0
        return False
    for d in range(5, int(n**0.5)+1,2):
        if n % d == 0
           return False

    return True

def isPrime（n）：#2,3,5轮
ws=[1,2,2,4,2,4,2,4,6,2,6]
w、 f=0，2
当f*f时，首先检查循环中的计数器，当计数器大于2时返回false。
def isPrime(n): # 2,3,5-wheel
    ws = [1,2,2,4,2,4,2,4,6,2,6]
    w, f = 0, 2
    while f * f <= n:
        if n % f == 0:
            return False
        f = f + ws[w]
        w = w + 1
        if w == 11: w = 3
    return True

def isPrime(n, k=5): # miller-rabin
    from random import randint
    if n < 2: return False
    for p in [2,3,5,7,11,13,17,19,23,29]:
        if n % p == 0: return n == p
    s, d = 0, n-1
    while d % 2 == 0:
        s, d = s+1, d/2
    for i in range(k):
        x = pow(randint(2, n-1), d, n)
        if x == 1 or x == n-1: continue
        for r in range(1, s):
            x = (x * x) % n
            if x == 1: return False
            if x == n-1: break
        else: return False
    return True

def primes(n): # sieve of eratosthenes
    i, p, ps, m = 0, 3, [2], n // 2
    sieve = [True] * m
    while p <= n:
        if sieve[i]:
            ps.append(p)
            for j in range((p*p-3)/2, m, p):
                sieve[j] = False
        i, p = i+1, p+2
    return ps

def primegen(start=0): # stackoverflow.com/a/20660551
    if start <= 2: yield 2    # prime (!) the pump
    if start <= 3: yield 3    # prime (!) the pump
    ps = primegen()           # sieving primes
    p = next(ps) and next(ps) # first sieving prime
    q = p * p; D = {}         # initialization
    def add(m, s):            # insert multiple/stride
        while m in D: m += s  #   find unused multiple
        D[m] = s              #   save multiple/stride
    while q <= start:         # initialize multiples
        x = (start // p) * p  #   first multiple of p
        if x < start: x += p  #   must be >= start
        if x % 2 == 0: x += p #   ... and must be odd
        add(x, p+p)           #   insert in sieve
        p = next(ps)          #   next sieving prime
        q = p * p             #   ... and its square
    c = max(start-2, 3)       # first prime candidate
    if c % 2 == 0: c += 1     # candidate must be odd
    while True:               # infinite list
        c += 2                #   next odd candidate
        if c in D:            #   c is composite
            s = D.pop(c)      #     fetch stride
            add(c+s, s)       #     add next multiple
        elif c < q: yield c   #   c is prime; yield it
        else: # (c == q)      #   add p to sieve
            add(c+p+p, p+p)   #     insert in sieve
            p = next(ps)      #     next sieving prime
            q = p * p         #     ... and its square