blocks|key|1207367|text|k+=+k-1这一行并不像您想的那样。它没有任何效果。更改k不会影响循环。在每次迭代中，k被分配给范围的下一个元素，因此您在循环中对k所做的任何更改都将被覆盖。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1207368|entityMap^0|0|7|T|1|18|1|1U|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

The line <code>k = k-1</code> does not do what you think. It has no effect. Changing <code>k</code> does not affect the loop. At each iteration, <code>k</code> is assigned to the next element of the range, so any changes you have made to <code>k</code> inside the loop will be overwritten.

blocks|key|1207406|text|这段代码非常混乱，我不知道你写这段代码时到底在想什么，也不知道你想要实现什么。当我试图弄清楚如何编码时，我建议的第一件事是让你的变量名非常具有描述性。这将帮助你在头脑中获得你正在做的事情的想法，它也将帮助任何试图帮助你展示如何让你的想法直截了当的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207407|话虽如此，下面是一个示例程序，它实现了接近目标的功能：|1207408|primewanted+=+int(input("This+program+will+give+you+the+nth+prime.\nPlease+enter+n:"))
if+primewanted+<=+0:
++++print+"n+must+be+>=+1"
else:
++++lastprime+=+2+#+2+is+the+very+first+prime+number
++++primesfound+=+1++#+Since+2+is+the+very+first+prime,+we've+found+1+prime
++++possibleprime+=+lastprime+%2B+1+#+Start+search+for+new+primes+right+after
++++while+primesfound+<+primewanted:
++++++++#+Start+at+2.++Things+divisible+by+1+might+still+be+prime
++++++++testdivisor+=+2
++++++++#+Something+is+still+possibly+prime+if+it+divided+with+a+remainder.
++++++++still_possibly_prime+=+((possibleprime+%25+testdivisor)+!=+0)
++++++++#+(testdivisor+%2B+1)+because+we+never+want+to+divide+a+number+by+itself.
++++++++while+still_possibly_prime+and+((testdivisor+%2B+1)+<+possibleprime):
++++++++++++testdivisor+=+testdivisor+%2B+1
++++++++++++still_possibly_prime+=+((possibleprime+%25+testdivisor)+!=+0)
++++++++#+If+after+all+that+looping+the+prime+is+still+possibly+prime,
++++++++#+then+it+is+prime.
++++++++if+still_possibly_prime:
++++++++++++lastprime+=+possibleprime
++++++++++++primesfound+=+primesfound+%2B+1
++++++++#+Go+on+ahead+to+see+if+the+next+number+is+prime
++++++++possibleprime+=+possibleprime+%2B+1
++++print+"This+nth+prime+is:",+lastprime|code-block|syntax|javascript|1207409|下面这段代码：|1207410|++++++++testdivisor+=+2
++++++++#+Something+is+still+possibly+prime+if+it+divided+with+a+remainder.
++++++++still_possibly_prime+=+((possibleprime+%25+testdivisor)+!=+0)
++++++++#+(testdivisor+%2B+1)+because+we+never+want+to+divide+a+number+by+itself.
++++++++while+still_possibly_prime+and+((testdivisor+%2B+1)+<+possibleprime):
++++++++++++testdivisor+=+testdivisor+%2B+1
++++++++++++still_possibly_prime+=+((possibleprime+%25+testdivisor)+!=+0)|1207411|可能会被一些缓慢的，但可能更容易理解的：|1207412|++++++++#+Assume+the+number+is+prime+until+we+prove+otherwise
++++++++still_possibly_prime+=+True
++++++++#+Start+at+2.++Things+divisible+by+1+might+still+be+prime
++++++++for+testdivisor+in+xrange(2,+possibleprime,+1):
++++++++++++#+Something+is+still+possibly+prime+if+it+divided+with+a
++++++++++++#+remainder.++And+if+it+is+ever+found+to+be+not+prime,+it's+not
++++++++++++#+prime,+so+never+check+again.
++++++++++++if+still_possibly_prime:
++++++++++++++++still_possibly_prime+=+((possibleprime+%25+testdivisor)+!=+0)|1207413|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This code is very confused, and I can't figure out exactly what you were thinking when you wrote it or what you were attempting to accomplish. The first thing I would suggest when trying to figure out how to code is to start by making your variable names extremely descriptive. This will help you get the ideas of what you're doing straight in your head, and it will also help anyone who's trying to help you show you how to get your ideas straight.

That being said, here is a sample program that accomplishes something close to the goal:

<pre><code>primewanted = int(input("This program will give you the nth prime.\nPlease enter n:"))
if primewanted &lt;= 0:
 print "n must be &gt;= 1"
else:
 lastprime = 2 # 2 is the very first prime number
 primesfound = 1 # Since 2 is the very first prime, we've found 1 prime
 possibleprime = lastprime + 1 # Start search for new primes right after
 while primesfound &lt; primewanted:
 # Start at 2. Things divisible by 1 might still be prime
 testdivisor = 2
 # Something is still possibly prime if it divided with a remainder.
 still_possibly_prime = ((possibleprime % testdivisor) != 0)
 # (testdivisor + 1) because we never want to divide a number by itself.
 while still_possibly_prime and ((testdivisor + 1) &lt; possibleprime):
 testdivisor = testdivisor + 1
 still_possibly_prime = ((possibleprime % testdivisor) != 0)
 # If after all that looping the prime is still possibly prime,
 # then it is prime.
 if still_possibly_prime:
 lastprime = possibleprime
 primesfound = primesfound + 1
 # Go on ahead to see if the next number is prime
 possibleprime = possibleprime + 1
 print "This nth prime is:", lastprime
</code></pre>

This bit of code:

<pre><code> testdivisor = 2
 # Something is still possibly prime if it divided with a remainder.
 still_possibly_prime = ((possibleprime % testdivisor) != 0)
 # (testdivisor + 1) because we never want to divide a number by itself.
 while still_possibly_prime and ((testdivisor + 1) &lt; possibleprime):
 testdivisor = testdivisor + 1
 still_possibly_prime = ((possibleprime % testdivisor) != 0)
</code></pre>

could possibly be replaced by the somewhat slow, but possibly more understandable:

<pre><code> # Assume the number is prime until we prove otherwise
 still_possibly_prime = True
 # Start at 2. Things divisible by 1 might still be prime
 for testdivisor in xrange(2, possibleprime, 1):
 # Something is still possibly prime if it divided with a
 # remainder. And if it is ever found to be not prime, it's not
 # prime, so never check again.
 if still_possibly_prime:
 still_possibly_prime = ((possibleprime % testdivisor) != 0)
</code></pre>

blocks|key|1422527|text|使用regexp+:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422528|#!/usr/bin/python

import+re,+sys


def+isPrime(n):
++++#+see+http://www.noulakaz.net/weblog/2007/03/18/a-regular-expression-to-check-for-prime-numbers/
++++return+re.match(r'%5E1?$%7C%5E(11%2B?)\1%2B$',+'1'+*+n)+==+None


N+=+int(sys.argv[1])+#+number+of+primes+wanted+(from+command-line)
M+=+100++++++++++++++#+upper-bound+of+search+space
l+=+list()+++++++++++#+result+list

while+len(l)+<+N:
++++l+%2B=+filter(isPrime,+range(M+-+100,+M))+#+append+prime+element+of+[M+-+100,+M]+to+l
++++M+%2B=+100++++++++++++++++++++++++++++++++#+increment+upper-bound

print+l[:N]+#+print+result+list+limited+to+N+elements|code-block|syntax|javascript|1422529|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

using a regexp :)

<pre><code>#!/usr/bin/python

import re, sys


def isPrime(n):
 # see http://www.noulakaz.net/weblog/2007/03/18/a-regular-expression-to-check-for-prime-numbers/
 return re.match(r'^1?$|^(11+?)\1+$', '1' * n) == None


N = int(sys.argv[1]) # number of primes wanted (from command-line)
M = 100 # upper-bound of search space
l = list() # result list

while len(l) &lt; N:
 l += filter(isPrime, range(M - 100, M)) # append prime element of [M - 100, M] to l
 M += 100 # increment upper-bound

print l[:N] # print result list limited to N elements
</code></pre>

blocks|key|1422567|text|你想要的是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422568|x+=+int(input("Enter+the+number:"))
count+=+0
num+=+2
while+count+<+x:
+++++if+isnumprime(x):
++++++++print(x)
++++++++count+%2B=+1
+++++num+%2B=+1|code-block|syntax|javascript|1422569|我将留给您来实现isnumprime()+;)提示:您只需要用之前找到的所有质数来测试除法。|offset|length|style|CODE|1422570|entityMap^0|0|0|8|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

What you want is something like this:
<pre><code>x = int(input(&quot;Enter the number:&quot;))
count = 0
num = 2
while count &lt; x:
 if isnumprime(x):
 print(x)
 count += 1
 num += 1
</code></pre>
I'll leave it up to you to implement <code>isnumprime()</code> ;)
Hint: You only need to test division with all previously found prime numbers.

blocks|key|1422602|text|直到我们有了N个素数，一个接一个地取自然数，检查到目前为止收集到的素数中是否有任何一个除以它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422603|如果没有，“耶”，我们有了一个新的素数...|1422604|就这样。|1422605|>>>+def+generate_n_primes(N):
...+++++primes++=+[]
...+++++chkthis+=+2
...+++++while+len(primes)+<+N:
...+++++++++ptest++++=+[chkthis+for+i+in+primes+if+chkthis%25i+==+0]
...+++++++++primes++%2B=+[]+if+ptest+else+[chkthis]
...+++++++++chkthis+%2B=+1
...+++++return+primes
...
>>>+print+generate_n_primes(15)
[2,+3,+5,+7,+11,+13,+17,+19,+23,+29,+31,+37,+41,+43,+47]|code-block|syntax|javascript|1422606|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Until we have N primes, take natural numbers one by one, check whether any of the so-far-collected-primes divide it. 

If none does, "yay", we have a new prime... 

that's it.

<pre><code>&gt;&gt;&gt; def generate_n_primes(N):
... primes = []
... chkthis = 2
... while len(primes) &lt; N:
... ptest = [chkthis for i in primes if chkthis%i == 0]
... primes += [] if ptest else [chkthis]
... chkthis += 1
... return primes
...
&gt;&gt;&gt; print generate_n_primes(15)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
</code></pre>

blocks|key|1422650|text|使用生成器表达式创建一个包含所有素数的序列，并将其中的第100个素数分割出来。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422651|from+itertools+import+count,+islice
primes+=+(n+for+n+in+count(2)+if+all(n+%25+d+for+d+in+range(2,+n)))
print("100th+prime+is+%25d"+%25+next(islice(primes,+99,+100)))|code-block|syntax|javascript|1422652|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using generator expressions to create a sequence of all primes and slice the 100th out of that.

<pre><code>from itertools import count, islice
primes = (n for n in count(2) if all(n % d for d in range(2, n)))
print("100th prime is %d" % next(islice(primes, 99, 100)))
</code></pre>

blocks|key|1207618|text|作为参考，不同的解决方案之间存在着非常显著的速度差异。下面是一些比较代码。Lennart指出的解决方案称为“历史性”，Ants提出的解决方案称为"naive"，RC提出的解决方案称为“regexp”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207619|from+sys+import+argv
from+time+import+time

def+prime(i,+primes):
++++for+prime+in+primes:
++++++++if+not+(i+==+prime+or+i+%25+prime):
++++++++++++return+False
++++primes.add(i)
++++return+i

def+historic(n):
++++primes+=+set([2])
++++i,+p+=+2,+0
++++while+True:
++++++++if+prime(i,+primes):
++++++++++++p+%2B=+1
++++++++++++if+p+==+n:
++++++++++++++++return+primes
++++++++i+%2B=+1

def+naive(n):
++++from+itertools+import+count,+islice
++++primes+=+(n+for+n+in+count(2)+if+all(n+%25+d+for+d+in+range(2,+n)))
++++return+islice(primes,+0,+n)

def+isPrime(n):
++++import+re
++++#+see+http://tinyurl.com/3dbhjv
++++return+re.match(r'%5E1?$%7C%5E(11%2B?)\1%2B$',+'1'+*+n)+==+None

def+regexp(n):
++++import+sys
++++N+=+int(sys.argv[1])+#+number+of+primes+wanted+(from+command-line)
++++M+=+100++++++++++++++#+upper-bound+of+search+space
++++l+=+list()+++++++++++#+result+list

++++while+len(l)+<+N:
++++++++l+%2B=+filter(isPrime,+range(M+-+100,+M))+#+append+prime+element+of+[M+-+100,+M]+to+l
++++++++M+%2B=+100++++++++++++++++++++++++++++++++#+increment+upper-bound

++++return+l[:N]+#+print+result+list+limited+to+N+elements

def+dotime(func,+n):
++++print+func.__name__
++++start+=+time()
++++print+sorted(list(func(n)))
++++print+'Time+in+seconds:+'+%2B+str(time()+-+start)

if+__name__+==+"__main__":
++++for+func+in+naive,+historic,+regexp:
++++++++dotime(func,+int(argv[1]))|code-block|syntax|javascript|1207620|在我的机器上，当n=+100时，输出结果是：|1207621|naive
[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,+541]
Time+in+seconds:+0.0219371318817
historic
[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,+541]
Time+in+seconds:+0.00515413284302
regexp
[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,+541]
Time+in+seconds:+0.0733318328857|1207622|正如你所看到的，这里有一个很大的差异。这里又是1000+(去掉了主输出)：|1207623|naive
Time+in+seconds:+1.49018788338
historic
Time+in+seconds:+0.148319005966
regexp
Time+in+seconds:+29.2350409031|1207624|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

For reference, there's a pretty significant speed difference between the various stated solutions. Here is some comparison code. The solution pointed to by Lennart is called "historic", the one proposed by Ants is called "naive", and the one by RC is called "regexp."

<pre><code>from sys import argv
from time import time

def prime(i, primes):
 for prime in primes:
 if not (i == prime or i % prime):
 return False
 primes.add(i)
 return i

def historic(n):
 primes = set([2])
 i, p = 2, 0
 while True:
 if prime(i, primes):
 p += 1
 if p == n:
 return primes
 i += 1

def naive(n):
 from itertools import count, islice
 primes = (n for n in count(2) if all(n % d for d in range(2, n)))
 return islice(primes, 0, n)

def isPrime(n):
 import re
 # see http://tinyurl.com/3dbhjv
 return re.match(r'^1?$|^(11+?)\1+$', '1' * n) == None

def regexp(n):
 import sys
 N = int(sys.argv[1]) # number of primes wanted (from command-line)
 M = 100 # upper-bound of search space
 l = list() # result list

 while len(l) &lt; N:
 l += filter(isPrime, range(M - 100, M)) # append prime element of [M - 100, M] to l
 M += 100 # increment upper-bound

 return l[:N] # print result list limited to N elements

def dotime(func, n):
 print func.__name__
 start = time()
 print sorted(list(func(n)))
 print 'Time in seconds: ' + str(time() - start)

if __name__ == "__main__":
 for func in naive, historic, regexp:
 dotime(func, int(argv[1]))
</code></pre>

The output of this on my machine for n = 100 is:

<pre><code>naive
[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, 541]
Time in seconds: 0.0219371318817
historic
[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, 541]
Time in seconds: 0.00515413284302
regexp
[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, 541]
Time in seconds: 0.0733318328857
</code></pre>

As you can see, there's a pretty big discrepancy. Here it is again for 1000 (prime outputs removed):

<pre><code>naive
Time in seconds: 1.49018788338
historic
Time in seconds: 0.148319005966
regexp
Time in seconds: 29.2350409031
</code></pre>

blocks|key|1422737|text|由David+Eppstein实现的超级快速筛子-在我的PC上，前1000个素数需要0.146秒：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1422738|def+gen_primes():
++++"""+Generate+an+infinite+sequence+of+prime+numbers.
++++"""
++++#+Maps+composites+to+primes+witnessing+their+compositeness.
++++#+This+is+memory+efficient,+as+the+sieve+is+not+"run+forward"
++++#+indefinitely,+but+only+as+long+as+required+by+the+current
++++#+number+being+tested.
++++#
++++D+=+{}++

++++#+The+running+integer+that's+checked+for+primeness
++++q+=+2++

++++while+True:
++++++++if+q+not+in+D:
++++++++++++#+q+is+a+new+prime.
++++++++++++#+Yield+it+and+mark+its+first+multiple+that+isn't
++++++++++++#+already+marked+in+previous+iterations
++++++++++++#+
++++++++++++yield+q++++++++
++++++++++++D[q+*+q]+=+[q]
++++++++else:
++++++++++++#+q+is+composite.+D[q]+is+the+list+of+primes+that
++++++++++++#+divide+it.+Since+we've+reached+q,+we+no+longer
++++++++++++#+need+it+in+the+map,+but+we'll+mark+the+next+
++++++++++++#+multiples+of+its+witnesses+to+prepare+for+larger
++++++++++++#+numbers
++++++++++++#+
++++++++++++for+p+in+D[q]:
++++++++++++++++D.setdefault(p+%2B+q,+[]).append(p)
++++++++++++del+D[q]

++++++++q+%2B=+1

primes+=+gen_primes()


x+=+set()
y+=+0
a+=+gen_primes()
while+y+<+10000:
++x+%7C=+set([a.next()])
++y%2B=1

print+"x+contains+{:,d}+primes".format(len(x))
print+"largest+is+{:,d}".format(sorted(x)[-1])|code-block|syntax|javascript|1422739|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/117119/^0|1|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Super quick sieve implementation by <a href="http://code.activestate.com/recipes/117119/" rel="nofollow noreferrer">David Eppstein</a> - takes 0.146s for the first 1000 primes on my PC:

<pre><code>def gen_primes():
 """ Generate an infinite sequence of prime numbers.
 """
 # Maps composites to primes witnessing their compositeness.
 # This is memory efficient, as the sieve is not "run forward"
 # indefinitely, but only as long as required by the current
 # number being tested.
 #
 D = {} 

 # The running integer that's checked for primeness
 q = 2 

 while True:
 if q not in D:
 # q is a new prime.
 # Yield it and mark its first multiple that isn't
 # already marked in previous iterations
 # 
 yield q 
 D[q * q] = [q]
 else:
 # q is composite. D[q] is the list of primes that
 # divide it. Since we've reached q, we no longer
 # need it in the map, but we'll mark the next 
 # multiples of its witnesses to prepare for larger
 # numbers
 # 
 for p in D[q]:
 D.setdefault(p + q, []).append(p)
 del D[q]

 q += 1

primes = gen_primes()


x = set()
y = 0
a = gen_primes()
while y &lt; 10000:
 x |= set([a.next()])
 y+=1

print "x contains {:,d} primes".format(len(x))
print "largest is {:,d}".format(sorted(x)[-1])
</code></pre>

blocks|key|1422773|text|下面是我最终想出的打印前n个素数的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422774|numprimes+=+raw_input('How+many+primes+to+print?++')
count+=+0
potentialprime+=+2

def+primetest(potentialprime):
++++divisor+=+2
++++while+divisor+<=+potentialprime:
++++++++if+potentialprime+==+2:
++++++++++++return+True
++++++++elif+potentialprime+%25+divisor+==+0:
++++++++++++return+False
++++++++while+potentialprime+%25+divisor+!=+0:
++++++++++++if+potentialprime+-+divisor+>+1:
++++++++++++++++divisor+%2B=+1
++++++++++++else:
++++++++++++++++return+True

while+count+<+int(numprimes):
++++if+primetest(potentialprime)+==+True:
++++++++print+'Prime+#'+%2B+str(count+%2B+1),+'is',+potentialprime
++++++++count+%2B=+1
++++potentialprime+%2B=+1|code-block|syntax|javascript|1422775|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's what I eventually came up with to print the first n primes:
<pre><code>numprimes = raw_input('How many primes to print? ')
count = 0
potentialprime = 2

def primetest(potentialprime):
 divisor = 2
 while divisor &lt;= potentialprime:
 if potentialprime == 2:
 return True
 elif potentialprime % divisor == 0:
 return False
 while potentialprime % divisor != 0:
 if potentialprime - divisor &gt; 1:
 divisor += 1
 else:
 return True

while count &lt; int(numprimes):
 if primetest(potentialprime) == True:
 print 'Prime #' + str(count + 1), 'is', potentialprime
 count += 1
 potentialprime += 1
</code></pre>

blocks|key|1422791|text|n=int(input("Enter+the+number::+"))

for+i+in+range(2,n):
++++p=i
++++k=0
++++for+j+in+range(2,p-1):
++++++++if(p%25j==0):
++++++++++++k=k%2B1
++++if(k==0):
++++++++print(p)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1422792|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>n=int(input("Enter the number:: "))

for i in range(2,n):
 p=i
 k=0
 for j in range(2,p-1):
 if(p%j==0):
 k=k+1
 if(k==0):
 print(p)
</code></pre>

blocks|key|1207752|text|我不熟悉Python，所以我正在写C计数器部分(懒得写伪代码..:P)寻找前n个素数..//打印所有素数..不用费心去做一个数组并返回它，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207753|void+find_first_n_primes(int+n){
+++int+count+=+0;
+++for(int+i=2;count<=n;i%2B%2B){
+++++factFlag+==+0;+//flag+for+factor+count...+
+++++for(int+k=2;k<sqrt(n)%2B1;k%2B%2B){
+++++++if(i%25k+==+0)+//+factor+found..
++++++++factFlag%2B%2B;
+++++}
++++++if(factFlag==0)//+no+factors+found+hence+prime..
++++++++{
+++++++++Print(i);+++//+prime+displayed..
+++++++++count%2B%2B;
++++++++}
+++}
}|code-block|syntax|javascript|1207754|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I am not familiar with Python so I am writing the C counter part(too lazy to write pseudo code.. :P)
To find the first n prime numbers.. 
// prints all the primes.. not bothering to make an array and return it etc..

<pre><code>void find_first_n_primes(int n){
 int count = 0;
 for(int i=2;count&lt;=n;i++){
 factFlag == 0; //flag for factor count... 
 for(int k=2;k&lt;sqrt(n)+1;k++){
 if(i%k == 0) // factor found..
 factFlag++;
 }
 if(factFlag==0)// no factors found hence prime..
 {
 Print(i); // prime displayed..
 count++;
 }
 }
}
</code></pre>

blocks|key|1207759|text|这可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207760|def+in_prime(n):
++++p=True
++++i=2
++++if+i**2<=n:
++++++++if+n%25i==0:
++++++++++++p=False
++++++++++++break
++++if+(p):
++++++++return+n|code-block|syntax|javascript|1207761|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might help:

<pre><code>def in_prime(n):
 p=True
 i=2
 if i**2&lt;=n:
 if n%i==0:
 p=False
 break
 if (p):
 return n
</code></pre>

blocks|key|1422857|text|def+isPrime(y):
++i=2
++while+i+<+y:
++++if+y%25i+==+0+:
++++++return+0
++++++exit()
++++i=i%2B1
++return+1

x=+raw_input('Enter+the+position+1st,2nd,..nth+prime+number+you+are+looking+for?:+')
z=int(x)
#+for+l+in+range(2,z)
count+=+1
n+=+2
while+count+<=+z:
++if+isPrime(n)+==+1:
++++if+count+==+z:
++++++print+n
++++count+%2B=1
++n=n%2B1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1422858|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def isPrime(y):
 i=2
 while i &lt; y:
 if y%i == 0 :
 return 0
 exit()
 i=i+1
 return 1

x= raw_input('Enter the position 1st,2nd,..nth prime number you are looking for?: ')
z=int(x)
# for l in range(2,z)
count = 1
n = 2
while count &lt;= z:
 if isPrime(n) == 1:
 if count == z:
 print n
 count +=1
 n=n+1
</code></pre>

blocks|key|1207810|text|这可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207811|import+sys
from+time+import+time
def+prime(N):
++++M=100
++++l=[]
++++while+len(l)+<+N:
++++++++for+i+in+range(M-100,M):++++
++++++++++++num+=+filter(lambda+y+:i+%25+y+==+0,(y+for+y+in+range(2+,(i/2))))+
++++++++++++if+not+num+and+i+not+in+[0,1,4]:
++++++++++++++++l.append(i)
++++++++M+%2B=100
++++return+l[:N]


def+dotime(func,+n):
++++print+func.__name__
++++start+=+time()
++++print+sorted(list(func(n))),len(list(func(n)))
++++print+'Time+in+seconds:+'+%2B+str(time()+-+start)


if+__name__+==+"__main__":
++++dotime(prime,+int(sys.argv[1]))|code-block|syntax|javascript|1207812|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This might help:

<pre><code>import sys
from time import time
def prime(N):
 M=100
 l=[]
 while len(l) &lt; N:
 for i in range(M-100,M): 
 num = filter(lambda y :i % y == 0,(y for y in range(2 ,(i/2)))) 
 if not num and i not in [0,1,4]:
 l.append(i)
 M +=100
 return l[:N]


def dotime(func, n):
 print func.__name__
 start = time()
 print sorted(list(func(n))),len(list(func(n)))
 print 'Time in seconds: ' + str(time() - start)


if __name__ == "__main__":
 dotime(prime, int(sys.argv[1]))
</code></pre>

blocks|key|1207870|text|下面是一个简单的递归版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1207871|import+datetime
import+math

def+is_prime(n,+div=2):
++++if+div>+int(math.sqrt(n)):+return+True
++++if+n%25+div+==+0:
++++++++return+False
++++else:
++++++++div%2B=1
++++++++return+is_prime(n,div)


now+=+datetime.datetime.now()

until+=+raw_input("How+many+prime+numbers+my+lord+desires???+")
until+=+int(until)

primelist=[]
i=1;
while+len(primelist)<until:
++++if+is_prime(i):
++++++++primelist.insert(0,i)
++++++++i%2B=1
++++else:+i%2B=1



print+"%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B%2B"
print+primelist
finish+=+datetime.datetime.now()
print+"It+took+your+computer",+finish+-+now+,+"secs+to+calculate+it"|code-block|syntax|javascript|1207872|下面是一个使用带内存的递归函数的版本：|1207873|import+datetime
import+math

def+is_prime(n,+div=2):
++++global+primelist
++++if+div>+int(math.sqrt(n)):+return+True
++++if+div+<+primelist[0]:
++++++++div+=+primelist[0]
++++++++for+x+in+primelist:
++++++++++++if+x+==0+or+x==1:+continue
++++++++++++if+n+%25+x+==+0:
++++++++++++++++return+False
++++if+n%25+div+==+0:
++++++++return+False
++++else:
++++++++div%2B=1
++++++++return+is_prime(n,div)


now+=+datetime.datetime.now()
print+'time+and+date:',now

until+=+raw_input("How+many+prime+numbers+my+lord+desires???+")
until+=+int(until)

primelist=[]
i=1;
while+len(primelist)<until:
++++if+is_prime(i):
++++++++primelist.insert(0,i)
++++++++i%2B=1
++++else:+i%2B=1



print+"Here+you+go!"
print+primelist

finish+=+datetime.datetime.now()
print+"It+took+your+computer",+finish+-+now+,+"+to+calculate+it"|1207874|希望它能有所帮助:)|1207875|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's a simple recursive version:

<pre><code>import datetime
import math

def is_prime(n, div=2):
 if div&gt; int(math.sqrt(n)): return True
 if n% div == 0:
 return False
 else:
 div+=1
 return is_prime(n,div)


now = datetime.datetime.now()

until = raw_input("How many prime numbers my lord desires??? ")
until = int(until)

primelist=[]
i=1;
while len(primelist)&lt;until:
 if is_prime(i):
 primelist.insert(0,i)
 i+=1
 else: i+=1



print "++++++++++++++++++++"
print primelist
finish = datetime.datetime.now()
print "It took your computer", finish - now , "secs to calculate it"
</code></pre>

Here's a version using a recursive function with memory!:

<pre><code>import datetime
import math

def is_prime(n, div=2):
 global primelist
 if div&gt; int(math.sqrt(n)): return True
 if div &lt; primelist[0]:
 div = primelist[0]
 for x in primelist:
 if x ==0 or x==1: continue
 if n % x == 0:
 return False
 if n% div == 0:
 return False
 else:
 div+=1
 return is_prime(n,div)


now = datetime.datetime.now()
print 'time and date:',now

until = raw_input("How many prime numbers my lord desires??? ")
until = int(until)

primelist=[]
i=1;
while len(primelist)&lt;until:
 if is_prime(i):
 primelist.insert(0,i)
 i+=1
 else: i+=1



print "Here you go!"
print primelist

finish = datetime.datetime.now()
print "It took your computer", finish - now , " to calculate it"
</code></pre>

Hope it helps :)

blocks|key|1422970|text|尝试使用while循环来检查计数，这很简单。找到下面的代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1422971|i=1
count+=+0;
x+=+int(input("Enter+the+number:\n"))
while+(count+<+x):
c=0
for+j+in+range+(1,+(i%2B1),+1):
++++a+=+i%25j
++++if+(a==0):
++++++++c+=+c%2B1

if+(c==2):
++++++print+(i)
++++++count+=+count%2B1
i=i%2B1|code-block|syntax|javascript|1422972|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try using while loop to check the count, that is easy. Find the code snippet below :

<pre><code>i=1
count = 0;
x = int(input("Enter the number:\n"))
while (count &lt; x):
c=0
for j in range (1, (i+1), 1):
 a = i%j
 if (a==0):
 c = c+1

if (c==2):
 print (i)
 count = count+1
i=i+1
</code></pre>

blocks|key|1423037|text|在Python+V3中使用素数时，我注意到复合(非素数)可被整除的最小数本身始终是小于被测数的平方根的素数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423038|下面是我用来计算前N个素数的实现。|1423039|0.028秒内的前1000个素数%7C0.6秒内的前10,000个素数%7C+14.3S内的前100,000个素数|1423040|下面的代码片段还指出了这一代花了多长时间，并以漂亮的表格格式打印出质数。|1423041|import+time
import+math

def+first_n_Primes(n):
++++number_under_test+=+4
++++primes+=+[2,3]
++++while+len(primes)+<+n:
++++++++check+=+False
++++++++for+prime+in+primes:
++++++++++++if+prime+>+math.sqrt(number_under_test)+:+break
++++++++++++if+number_under_test+%25+prime+==+0:
++++++++++++++++check+=+True
++++++++++++++++break
++++++++if+not+check:
++++++++++++for+counter+in+range(primes[len(primes)-1],number_under_test-1,2):
++++++++++++++++if+number_under_test+%25+counter+==+0:
++++++++++++++++++++check+=+True
++++++++++++++++++++break
++++++++if+not+check:
++++++++++++primes.append(number_under_test)
++++++++number_under_test%2B=1
++++return+primes

start_time+=+time.time()
data+=+first_n_Primes(1000)
end_time+=+time.time()

i+=+1
while+i+<+len(data)%2B1:
++++print('{0:+<9}'.format(str(data[i-1])),+end="")
++++if+i%2510+==+0:+print("")
++++i%2B=1

print("\nFirst+%25d+primes+took+%25s+seconds+---"+%25+(len(data),end_time+-+start_time))|code-block|syntax|javascript|1423042|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Whilst playing with prime numbers in Python V3 I noticed that the smallest number by which a composite(non-prime) number is divisible is itself always a prime that is less than the square root of the number under test.

Below is my implementation of that finding to calculate the first N prime numbers.

first 1,000 primes in 0.028S | first 10,000 primes in 0.6S | first 100,000 primes in 14.3S

The snippet below also indicates how long the generation took and prints out the primes in a nice table format.

<pre><code>import time
import math

def first_n_Primes(n):
 number_under_test = 4
 primes = [2,3]
 while len(primes) &lt; n:
 check = False
 for prime in primes:
 if prime &gt; math.sqrt(number_under_test) : break
 if number_under_test % prime == 0:
 check = True
 break
 if not check:
 for counter in range(primes[len(primes)-1],number_under_test-1,2):
 if number_under_test % counter == 0:
 check = True
 break
 if not check:
 primes.append(number_under_test)
 number_under_test+=1
 return primes

start_time = time.time()
data = first_n_Primes(1000)
end_time = time.time()

i = 1
while i &lt; len(data)+1:
 print('{0: &lt;9}'.format(str(data[i-1])), end="")
 if i%10 == 0: print("")
 i+=1

print("\nFirst %d primes took %s seconds ---" % (len(data),end_time - start_time))
</code></pre>

blocks|key|1423139|text|这是我的版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423140|import+timeit
import+math

__author__+=+'rain'


primes+=+[2]

def+is_prime(n):
++++for+prime+in+primes:
++++++++if+n+%25+prime+==+0:
++++++++++++return+False
++++return+True


def+find_nth_prime(n):
++++current_index+=+0
++++while(len(primes)+<+n):
++++++++if+current_index+==+0:
++++++++++++start_value+=+3
++++++++++++end_value+=+2+*+2
++++++++else:
++++++++++++start_value+=+primes[current_index+-+1]+*+primes[current_index+-+1]+%2B+1
++++++++++++end_value+=+primes[current_index]+*+primes[current_index]
++++++++for+i+in+range(start_value,+end_value):
++++++++++++if+is_prime(i):
++++++++++++++++primes.append(i)
++++++++current_index+%2B=+1
++++return+primes[n-1]


def+solve():
++++return+find_nth_prime(10001)

print+solve()

print+timeit.timeit(solve,+number=10)|code-block|syntax|javascript|1423141|我用筛子扫描素数，速度很快|1423142|它只需要3.8e-06秒就可以获得10001次素数(10次)。|1423143|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is my version

<pre><code>import timeit
import math

__author__ = 'rain'


primes = [2]

def is_prime(n):
 for prime in primes:
 if n % prime == 0:
 return False
 return True


def find_nth_prime(n):
 current_index = 0
 while(len(primes) &lt; n):
 if current_index == 0:
 start_value = 3
 end_value = 2 * 2
 else:
 start_value = primes[current_index - 1] * primes[current_index - 1] + 1
 end_value = primes[current_index] * primes[current_index]
 for i in range(start_value, end_value):
 if is_prime(i):
 primes.append(i)
 current_index += 1
 return primes[n-1]


def solve():
 return find_nth_prime(10001)

print solve()

print timeit.timeit(solve, number=10)
</code></pre>

I use a sieve to scan primes, it's quite quick

It's take only 3.8e-06 seconds to get 10001th prime (10 times).

blocks|key|1423151|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423152|primeList+=+[]
for+num+in+range(2,10000):
++++if+all(num%25i!=0+for+i+in+range(2,num)):
++++++++primeList.append(num)
x+=+int(raw_input("Enter+n:+"))
for+i+in+range(x):
++++print+primeList[i]|code-block|syntax|javascript|1423153|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

<pre><code>primeList = []
for num in range(2,10000):
 if all(num%i!=0 for i in range(2,num)):
 primeList.append(num)
x = int(raw_input("Enter n: "))
for i in range(x):
 print primeList[i]
</code></pre>

blocks|key|1208103|text|max+=+input("enter+the+maximum+limit+to+check+prime+number");
if+max>1+:
++++for+i+in+range+(2,max):
++++++++prime=0;
++++++++for+j+in+range+(2,i):
++++++++++++if(i%25j==0):
++++++++++++++++prime=1;
++++++++++++++++break
++++++++if(prime==0+and+i!=0):
++++++++++++print(i,"is+prime+number");
else:
++++print("prime+no+start+from+2");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1208104|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>max = input("enter the maximum limit to check prime number");
if max&gt;1 :
 for i in range (2,max):
 prime=0;
 for j in range (2,i):
 if(i%j==0):
 prime=1;
 break
 if(prime==0 and i!=0):
 print(i,"is prime number");
else:
 print("prime no start from 2");
</code></pre>

blocks|key|1208176|text|def+Isprime(z):
++++'''returns+True+if+the+number+is+prime+OTW+returns+false'''
++++if+z<1:
++++++++return+False
++++elif+z==1:
++++++++return+False

++++elif+z==2:
++++++++return+True+

++++else:
++++++++for+i+in+range(2,z):
++++++++++++if+z%25i==0:
++++++++++++++++return+False
++++++++++++else:
++++++++++++++++return+True|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1208177|我就是这么做的。当然，有很多方法可以做到这一点。|unstyled|1208178|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>def Isprime(z):
 '''returns True if the number is prime OTW returns false'''
 if z&lt;1:
 return False
 elif z==1:
 return False

 elif z==2:
 return True 

 else:
 for i in range(2,z):
 if z%i==0:
 return False
 else:
 return True
</code></pre>

This is the way I did it. Of course, there are so many ways you can do it.

blocks|key|1423214|text|prime=2
counter+=+0
x+=+int(input("Enter+the+number:\n"))
while+(counter+<+x):
++++if+all(prime%25j!=0+for+j+in+range(2,+prime)):
++++++++print(prime,+"is+a+prime+number")
++++++++counter%2B=1


++++prime%2B=1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1423215|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>prime=2
counter = 0
x = int(input("Enter the number:\n"))
while (counter &lt; x):
 if all(prime%j!=0 for j in range(2, prime)):
 print(prime, "is a prime number")
 counter+=1


 prime+=1
</code></pre>

blocks|key|1423266|text|您可以获取质数输入的数量。根据您的方法，我在这里采用了预定义的计数10：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423267|i+=+2
if+i+==+2:
++++print(str(i)+%2B+"is+a+prime+no")
++++i+=+i%2B1
c=1

while+c<10:
++++for+j+in+range(2,+i):
++++++++if+i%25j==0:
++++++++++++break

++++if+i+==+j%2B1:
++++++++print(str(i)+%2B+"is+aa+prime+no")
++++++++c=c%2B1

++++i=i%2B1|code-block|syntax|javascript|1423268|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can take the number of prime number inputs. As per your method I have taken here a predefined count of 10: 

<pre><code>i = 2
if i == 2:
 print(str(i) + "is a prime no")
 i = i+1
c=1

while c&lt;10:
 for j in range(2, i):
 if i%j==0:
 break

 if i == j+1:
 print(str(i) + "is aa prime no")
 c=c+1

 i=i+1
</code></pre>

blocks|key|1208270|text|count+=+-1
n+=+int(raw_input("how+many+primes+you+want+starting+from+2+"))
primes=[[]]*n
for+p+in+range(2,+n**2):
++++for+i+in+range(2,+p):
++++++++if+p+%25+i+==+0:
++++++++++++break
++++else:
++++++++count+%2B=1
++++++++primes[count]=+p
++++++++if+count+==+n-1:
++++++++++++break

print+(primes)
print+'Done'|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1208271|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>count = -1
n = int(raw_input("how many primes you want starting from 2 "))
primes=[[]]*n
for p in range(2, n**2):
 for i in range(2, p):
 if p % i == 0:
 break
 else:
 count +=1
 primes[count]= p
 if count == n-1:
 break

print (primes)
print 'Done'
</code></pre>

blocks|key|1208305|text|Anwer在这里很简单，即运行循环'n‘次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1208306|n=int(input())
count=0
i=2
while+count<n:
++++flag=0
++++j=2
++++while+j<=int(i**0.5):
++++++++if+i%25j==0:
++++++++++++flag%2B=1
++++++++j%2B=1
++++if+flag==0:
++++++++print(i,end="+")
++++++++count%2B=1
++++i%2B=1|code-block|syntax|javascript|1208307|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Anwer here is simple i.e run the loop 'n' times.

<pre><code>n=int(input())
count=0
i=2
while count&lt;n:
 flag=0
 j=2
 while j&lt;=int(i**0.5):
 if i%j==0:
 flag+=1
 j+=1
 if flag==0:
 print(i,end=" ")
 count+=1
 i+=1
</code></pre>

blocks|key|1423330|text|#!/usr/bin/python3
import+sys

primary_numbers+=+[1,+2]


def+is_prime(i):
++++for+pn+in+enumerate(primary_numbers[2:]):
++++++++if+i+%25+pn[1]+==+0:
++++++++++++return+False

++++return+True

def+main(position):
++++i+=+3
++++while+len(primary_numbers)+<+int(position):
++++++++print(i)
++++++++res+=+is_prime(i)
++++++++if+res:
++++++++++++primary_numbers.append(i)
++++++++i+%2B=+2


if+__name__+==+'__main__':
++++position+=+sys.argv[1]
++++main(position)
++++print(primary_numbers)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1423331|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#!/usr/bin/python3
import sys

primary_numbers = [1, 2]


def is_prime(i):
 for pn in enumerate(primary_numbers[2:]):
 if i % pn[1] == 0:
 return False

 return True

def main(position):
 i = 3
 while len(primary_numbers) &lt; int(position):
 print(i)
 res = is_prime(i)
 if res:
 primary_numbers.append(i)
 i += 2


if __name__ == '__main__':
 position = sys.argv[1]
 main(position)
 print(primary_numbers)
</code></pre>

blocks|key|1423366|text|嗨!我对编程非常陌生，4天前才刚开始。我写了一段代码，返回包括1在内的前1000个质数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423367|n=1
c=0
while+n>0:
+++for+i+in+range(2,n):
++++++if+n%25i+==+0:
+++++++++break
+++else:
++++++print(n,'is+a+prime')
++++++c=c%2B1
+++n=n%2B1
+++if+c==1000:
++++++break|code-block|syntax|javascript|1423368|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h3>Hi! I am very new to coding, just started 4 days back. I wrote a code to give back the first 1000 prime numbers including 1. Have a look</h3>
<pre><code>n=1
c=0
while n&gt;0:
 for i in range(2,n):
 if n%i == 0:
 break
 else:
 print(n,'is a prime')
 c=c+1
 n=n+1
 if c==1000:
 break
</code></pre>

blocks|key|1208409|text|def+isprime(n):
++++if+n+<=+1:
++++++++return+False
++++for+x+in+range(2,+n):
++++++++if+n+%25+x+==+0:
++++++++++++return+False
++++else:
++++++++return+True

def+list_prime(z):
++++y+=+0
++++def+to_infinity():
++++++++index=0
++++++++while+1:
++++++++++++yield+index
++++++++++++index+%2B=+1
++++for+n+in+to_infinity():
++++++++if+y+<+z:
++++++++++++if+isprime(n):
++++++++++++++++y+=+y+%2B+1
++++++++++++++++print(n,+end='\n',+flush=True)
++++++++else:break
++++print(f'\n+{z}+prime+numbers+are+as+above.')

#+put+your+range+below
list_prime(10)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1208410|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def isprime(n):
 if n &lt;= 1:
 return False
 for x in range(2, n):
 if n % x == 0:
 return False
 else:
 return True

def list_prime(z):
 y = 0
 def to_infinity():
 index=0
 while 1:
 yield index
 index += 1
 for n in to_infinity():
 if y &lt; z:
 if isprime(n):
 y = y + 1
 print(n, end='\n', flush=True)
 else:break
 print(f'\n {z} prime numbers are as above.')

# put your range below
list_prime(10)
</code></pre>

blocks|key|1423433|text|信仰者|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1423434|import+math

n+=+10000+#first+10000+primes
tmp_n+=+1
p+=+3
primes+=+[2]

while+tmp_n+<+n:

++++is_prime+=+True
++++for+i+in+range(3,+int(math.sqrt(p)+%2B+1),+2):
++++++++#+range+with+step+2

++++++++if+p+%25+i+==+0:
++++++++++++is_prime+=+False

++++if+is_prime:
++++++++primes+%2B=+[p]
++++++++tmp_n+%2B=+1

++++p+%2B=+2

print(primes)|code-block|syntax|javascript|1423435|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Fastests
<pre><code>import math

n = 10000 #first 10000 primes
tmp_n = 1
p = 3
primes = [2]

while tmp_n &lt; n:

 is_prime = True
 for i in range(3, int(math.sqrt(p) + 1), 2):
 # range with step 2

 if p % i == 0:
 is_prime = False

 if is_prime:
 primes += [p]
 tmp_n += 1

 p += 2

print(primes)
</code></pre>

blocks|key|1208461|text|#Simple+python+program+to+print+N+prime+numbers+

++++inp+=+int(input("required+prime+numbers"))
++++list+=set+()
++++num+=1
++++while(1):
++++++for+i+in+range(2,num):
+++++++++if+num%25i==0:
++++++++++++#print("not+prime")
++++++++++++break
++++++else:
++++++++++#print("prime")
++++++++++list.add(num)++++
++++++if+len(list)<inp:
++++++++++num=num%2B1
++++++else:
++++++++++break
++++print("n+primes:",list)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1208462|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#Simple python program to print N prime numbers 

 inp = int(input(&quot;required prime numbers&quot;))
 list =set ()
 num =1
 while(1):
 for i in range(2,num):
 if num%i==0:
 #print(&quot;not prime&quot;)
 break
 else:
 #print(&quot;prime&quot;)
 list.add(num) 
 if len(list)&lt;inp:
 num=num+1
 else:
 break
 print(&quot;n primes:&quot;,list)
</code></pre>

I am new to the programming world. I was just writing this code in python to generate N prime numbers. User should input the value for N which is the total number of prime numbers to print out. I have written this code but it doesn't throw the desired output. Instead it prints the prime numbers till the Nth number.
For example: User enters the value of N = 7.
Desired output: 2, 3, 5, 7, 11, 13, 19
Actual output: 2, 3, 5, 7
Kindly advise.
<pre><code>i = 1
x = int(input(&quot;Enter the number:&quot;))
for k in range(1, x+1):
 c = 0
 for j in range(1, i+1):
 a = i % j
 if a == 0:
 c = c + 1

 if c == 2:
 print(i)
 else:
 k = k - 1

 i = i + 1
</code></pre>

To find first N prime numbers in python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我是编程领域的新手。我只是用python写了这段代码来生成N个素数。用户应输入N的值，该值是要打印的质数的总数。我已经写了这段代码，但它没有抛出所需的输出。相反，它打印质数，直到第N个数字。例如:用户输入值N= 7。期望输出: 2，3，5，7，11，13，19实际输出: 2，3，5，7敬请指教。i = 1x = int...

问在python中查找前N个素数
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在python中查找前N个素数EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在python中查找前N个素数
EN