如何在python中生成第1000个素数？

你的逻辑不太正确。 而：

这无法判断一个数字是否为素数

---

我想你应该检查是否所有低于sqrt（i）的数字都除以i。

有几个问题是显而易见的。首先，因为你从11开始，你已经跳过了前5个素数，所以计数应该从5开始

更重要的是，你的素数检测算法根本不起作用。对于这种简单的“埃拉托斯坦筛”——比如素数检测，你必须跟踪所有比我小的素数。例如，您的算法会认为11*13=143是素数，但显然不是

---

PGsimple1是你在这里尝试的质数检测的正确实现，但是那里的其他算法要快得多。

我在某处遇到了一个is_prime函数，可能是这样的

if i%2 != 0:
    if (i%3 == 0 or i%4 == 0 or i%5 == 0 or i%6 == 0 or i%7 == 0 or i%9 == 0):

def为素数（n）：
返回xrange（2，n）中j的全部（（n%j>0））
素数=[]
n=1
而len（primes）你确定你正确地检查了primes吗？一个典型的解决方案是有一个单独的“iPrime”函数，你知道它是有效的

primes = []    
n = 1
while len(primes) <= 1000: 
    if all((n%j > 0) for j in xrange(2, n)):
        primes.append(n)
    n += 1

（有一些方法可以使上述函数更有效，例如只检查赔率，只检查平方根以下的数字等。）

然后，要找到第n个素数，计算所有素数，直到找到为止：

def isPrime(num):
    i = 0
    for factor in xrange(2, num):
        if num%factor == 0:
            return False
    return True

def nthPrime（n）：
找到=0
猜测=1
当发现
这可能更快：尝试将num从2分为sqrt（num）+1，而不是范围（2，num）

从数学导入sqrt
i=2
计数=1
尽管如此：
i+=1
素数=真
div=2
限值=sqrt（i）+1
当div
试试这个：

def isprime（num）：
计数=num//2+1
当计数>1时：
如果num%count==0：
返回错误
计数-=1
其他：
返回真值
num=0
计数=0
当计数小于1000时：
num+=1
如果是iPrime（num）：
计数+=1
如果计数=1000：
prime=num

代码的问题：

不需要检查我是否让我们看看

if i%2 != 0:
    if (i%3 == 0 or i%4 == 0 or i%5 == 0 or i%6 == 0 or i%7 == 0 or i%9 == 0):

如果
i%k==0
，则
i
不是素数。如果我们检测到它不是素数，我们应该（a）不打印它，（b）不增加找到的素数的计数器，（c）我们确实应该从
for
循环中跳出来-不需要再测试任何数字

另外，我们不需要测试
i%2
，而只需从
3
开始，按
2
的增量即可-通过构造，它们都是奇数

所以，我们现在有

count = 1
i = 3
while count != 1000:
    if i%2 != 0:
       for k in range(2,i):
          if i%k == 0:        # 'i' is _not_ a prime!
            print(i)       # ??
            count += 1     # ??
            break
     i += 1          # should be one space to the left,
                     # for proper indentation

如果
for
循环没有过早中断，则执行
for
之后的
else

它可以工作，但是工作太辛苦了，所以比需要的慢得多。它通过下面的所有数字来测试一个数字，但只要测试到它的平方根就足够了。为什么？因为如果一个数
n==p*q
，且
p
和
q
介于
1
和
n
之间，那么
p
或
q
中至少有一个将不大于
n
的平方根：如果它们都大于，它们的乘积将大于
n

因此：

在这里测试的这个范围内，真正无界的速度大约快1.5倍。
这个怎么样：

from math import log

count = 1 ; i = 1 ; D = {}
n = 100000                        # 20k:0.20s 
m = int(n*(log(n)+log(log(n))))   # 100k:1.15s 200k:2.36s-7.8M 
while count < n:                  #            400k:5.26s-8.7M 
        i += 2                    #            800k:11.21-7.8M 
        if i not in D:            #            1mln:13.20-7.8M (n^1.1)
            count += 1
            k = i*i
            if k > m:  break      # break, when all is already marked
            while k <= m:
                D[k] = 0 
                k += 2*i
while count < n:
        i += 2
        if i not in D: count += 1
if i >= m: print "invalid: top value estimate too small",i,m ; error
print i,m  

#/usr/bin/python
从数学导入sqrt
def是_prime（n）：
如果n==2：
返回真值
如果（n<2）或（n%2==0）：
返回错误
返回全部（n%i代表xrange中的i（3，int（sqrt（n））+1，2））
def哪个_prime（N）：
n=2
p=1
尽管如此：
x=是素数（n）
如果x：
如果p==N：
返回n
其他：
p+=1
n+=1
打印哪个_素数（1000）
这里是另一个提交：

n=2                         ## the first prime no.
prime=1                     ## we already know 2 is the first prime no.
while prime!=1000:          ## to get 1000th prime no.
    n+=1                    ## increase number by 1
    pon=1                   ## sets prime_or_not(pon) counter to 1
    for i in range(2,n):    ## i varies from 2 to n-1
        if (n%i)==0:        ## if n is divisible by i, n is not prime
            pon+=1          ## increases prime_or_not counter if  n is not prime
    if pon==1:              ## checks if n is prime or not at the end of for loop
        prime+=1            ## if n is prime, increase prime counter by 1
print n                     ## prints the thousandth prime no.

ans=0；
primeCounter=0；
当primeCounter<1000时：
ans+=1；
如果ans%2！=0: 
#我们有一个奇数
#开始测试素数
除数=2；
isPrime=True；
除数
这里有一个只使用if&while循环的方法。这将只打印出第1000个素数。它跳过了2。我是作为麻省理工学院开放式课程6.00的习题集1来做这件事的&因此只包括第二堂课之前教授的命令

ans = 0;
primeCounter = 0;
while primeCounter < 1000:
    ans += 1;    
    if ans % 2 != 0: 
        # we have an odd number
        # start testing for prime
        divisor = 2;
        isPrime = True;
        while divisor < ans:
            if ans % divisor == 0: 
                isPrime = False;
                break;
            divisor += 1;
        if isPrime:             
            print str(ans) + ' is the ' + str(primeCounter) + ' prime';
            primeCounter += 1;
print 'the 1000th prime is ' + str(ans);

prime\u计数器=0
数字=3
而（基本计数器<999）：
除数=2
divcounter=0
while（除数<数）：
如果（数字%除数==0）：
divcounter=1
除数+=1
如果（divcounter==0）：
素数计数器+=1
如果（素数计数器==999）：
打印“第1000个素数：”，数字
数字+=2
我刚刚写了这个。它会问您用户想要看到多少素数，在本例中是1000。请随意使用它：）

#p是素数系列的序列号
#n是要测试的自然数序列，无论是否为素数
#i是自然数的序列，用于确定n进行测试
#L是用户希望看到的素数系列的序列极限
p=2；n=3
L=int（输入（'输入要查看的质数：'））
打印（“#1素数是2”）
虽然（p这将是执行次数较少的优化代码，但它可以在一秒钟内计算并显示10000个素数。
它将显示所有素数，如果只需要第n个素数，只需设置while条件和pri
if i%2 != 0:
    if (i%3 == 0 or i%4 == 0 or i%5 == 0 or i%6 == 0 or i%7 == 0 or i%9 == 0):

count = 1
i = 3
while count != 1000:
    if i%2 != 0:
       for k in range(2,i):
          if i%k == 0:        # 'i' is _not_ a prime!
            print(i)       # ??
            count += 1     # ??
            break
     i += 1          # should be one space to the left,
                     # for proper indentation

count = 1
i = 3
while count != 1000:
    for k in range(2,i):
        if i%k == 0:       
            break
    else:
        print(i)
        count += 1
    i += 2        

from math import sqrt

count = 1
i = 1
while count < 1000:
    i += 2
    for k in range(2, 1+int(sqrt(i+1))):
        if i%k == 0:       
            break
    else:
        # print(i) ,
        count += 1
        # if count%20==0: print ""
print i

from math import log

count = 1 ; i = 1 ; D = {}
n = 100000                        # 20k:0.20s 
m = int(n*(log(n)+log(log(n))))   # 100k:1.15s 200k:2.36s-7.8M 
while count < n:                  #            400k:5.26s-8.7M 
        i += 2                    #            800k:11.21-7.8M 
        if i not in D:            #            1mln:13.20-7.8M (n^1.1)
            count += 1
            k = i*i
            if k > m:  break      # break, when all is already marked
            while k <= m:
                D[k] = 0 
                k += 2*i
while count < n:
        i += 2
        if i not in D: count += 1
if i >= m: print "invalid: top value estimate too small",i,m ; error
print i,m  

#!/usr/bin/python

from math import sqrt

def is_prime(n):
    if n == 2:
        return True
    if (n < 2) or (n % 2 == 0):
        return False
    return all(n % i for i in xrange(3, int(sqrt(n)) + 1, 2))

def which_prime(N):
    n = 2
    p = 1
    while True:
        x = is_prime(n)
        if x:
            if p == N:
                return n
            else:
                p += 1
        n += 1
print which_prime(1000)

n=2                         ## the first prime no.
prime=1                     ## we already know 2 is the first prime no.
while prime!=1000:          ## to get 1000th prime no.
    n+=1                    ## increase number by 1
    pon=1                   ## sets prime_or_not(pon) counter to 1
    for i in range(2,n):    ## i varies from 2 to n-1
        if (n%i)==0:        ## if n is divisible by i, n is not prime
            pon+=1          ## increases prime_or_not counter if  n is not prime
    if pon==1:              ## checks if n is prime or not at the end of for loop
        prime+=1            ## if n is prime, increase prime counter by 1
print n                     ## prints the thousandth prime no.

ans = 0;
primeCounter = 0;
while primeCounter < 1000:
    ans += 1;    
    if ans % 2 != 0: 
        # we have an odd number
        # start testing for prime
        divisor = 2;
        isPrime = True;
        while divisor < ans:
            if ans % divisor == 0: 
                isPrime = False;
                break;
            divisor += 1;
        if isPrime:             
            print str(ans) + ' is the ' + str(primeCounter) + ' prime';
            primeCounter += 1;
print 'the 1000th prime is ' + str(ans);

prime_counter = 0  
number = 3  

while(prime_counter < 999):
    divisor = 2
    divcounter = 0
    while(divisor < number):
        if(number%divisor == 0):
            divcounter = 1  
        divisor += 1
    if(divcounter == 0):
        prime_counter+=1
    if(prime_counter == 999):
        print '1000th prime number: ', number
    number+=2

# p is the sequence number of prime series
# n is the sequence of natural numbers to be tested if prime or not
# i is the sequence of natural numbers which will be used to devide n for testing
# L is the sequence limit of prime series user wants to see
p=2;n=3
L=int(input('Enter the how many prime numbers you want to see: '))
print ('# 1  prime is 2')
while(p<=L):
    i=2
    while i<n:
        if n%i==0:break
        i+=1
    else:print('#',p,' prime is',n); p+=1
    n+=1 #Line X

#when it breaks it doesn't execute the else and goes to the line 'X' 

import math
number=1
count = 0

while(count<10000):
    isprime=1
    number+=1
    for j in range(2,int(math.sqrt(number))+1):
        if(number%j==0):
            isprime=0   
            break
    if(isprime==1):
        print(number,end=" ")
        count+=1