Question

所以我能够通过互联网的一些帮助来解决这个问题，这就是我所得到的：

def isPrime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False

    return True

但我的问题是如何做到这一点，但为什么呢。我知道1不被认为是“素数”，即使它是，并且我理解如果它在范围内除以ANYTHING则自动为素数，因此返回False语句。但是我的问题是“n”在这里扮演什么角色？非常感谢你的关注

P.S。我很缺乏经验，一个月前刚刚开始编程：S

Answer 1

在互联网上的许多素性测试中，请考虑以下主要测试：

def is_prime(n):
  if n == 2 or n == 3: return True
  if n < 2 or n%2 == 0: return False
  if n < 9: return True
  if n%3 == 0: return False
  r = int(n**0.5)
  f = 5
  while f <= r:
    print '\t',f
    if n%f == 0: return False
    if n%(f+2) == 0: return False
    f +=6
  return True

考虑素数5003：

print is_prime(5003)

打印：

行r = int(n**0.5)的计算结果为70（5003的平方根为70.7318881411，int()截断此值）

由于前几个测试和循环中间的测试，循环只需要每隔6个数字进行一次评估。

考虑下一个奇数（因为除了2之外的所有偶数都不是素数）5005，同样的东西打印：

 5
False

限制是自x*y == y*x以来的平方根。该函数只需要进行1循环就可以找到5005可被5整除，因此不是素数。由于5 X 1001 == 1001 X 5（两者都是5005），我们不需要在循环中一直到1001来知道我们在5处知道什么！

现在，让我们来看看你的算法：

def isPrime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False

    return True

有两个问题：

不测试n是否小于2，且没有小于2的素数;
它测试2和n ** 0.5之间的每个数字，包括所有偶数和所有奇数。由于每个可被2整除的大于2的数字不是素数，我们可以通过仅测试大于2的奇数来加速它。

所以：

def isPrime2(n):
    if n==2 or n==3: return True
    if n%2==0 or n<2: return False
    for i in range(3,int(n**0.5)+1,2):   # only odd numbers
        if n%i==0:
            return False    

    return True

好的 - 加快了约30％（我对它进行基准测试......）

我使用的算法is_prime大约快2倍，因为只有每6个整数循环一次。（再一次，我对它进行了基准测试。）

旁注：x ** 0.5是平方根：

>>> import math
>>> math.sqrt(100)==100**0.5
True

旁注2：primality testing是计算机科学中一个有趣的问题。

Answer 2

使用n**.5，你不是平方n，而是取平方根。

考虑数字20;整数因子是1,2,4,5,10和20.当你将20除以2并得到10时，你知道它也可以被10整除，而不必检查。当你将它除以4并得到5时，你知道它可以被4和5整除，而不必检查5。

在达到因素的中间点后，您将没有更多数字来检查您之前尚未识别的因素。因此，您只需要中途看看是否有一些素数，并且可以通过取数字的平方根来找到这个中间点。

另外，原因1不是素数是因为素数被定义为具有2个因子，1和它们本身。即2是1 * 2,3是1 * 3,5是1 * 5。但是1（1 * 1）本身只有1个因子。因此，它不符合这个定义。

Answer 3

之前问过这个问题，但我有一个较短的解决方案

isPrime(Number):
    return 2 in [Number,2**Number%Number]

如果数字是素数，则数学运算将始终返回2，而不是2.但如果2是给定数字，则它将附加到我们正在查看的列表中。

2^5=32    32%5=2
2^7=128   128%7=2
2^11=2048 2048%11=2

依旧......

如果Number为Prime，则isPrime（）返回True，否则返回False。

Answer 4

下面没有进行浮点运算。这更快，并且可以容忍更高的论点。你必须只去平方根的原因是，如果一个数字的因子大于它的平方根，它也有一个小于它的因子。

def is_prime(n):
    """"pre-condition: n is a nonnegative integer
    post-condition: return True if n is prime and False otherwise."""
    if n < 2: 
         return False;
    if n % 2 == 0:             
         return n == 2  # return False
    k = 3
    while k*k <= n:
         if n % k == 0:
             return False
         k += 2
    return True

Answer 5

查找数字的平方根是为了提高效率。例如。如果我试图找到36的因子，可以自己乘以形成36的最高数字是6. 7 * 7 = 49.

因此，36的每个因子必须乘以6或更少的数字。

Answer 6

def is_prime(x):
    if x < 2:
        return False
    elif x == 2:
        return True  
    for n in range(2, x):
        if x % n ==0:
            return False
    return True

Answer 7

此方法将比此处的递归和枚举方法慢，但使用Wilson's theorem，并且只是一行：

from math import factorial

def is_prime(x):
    return factorial(x - 1)  % x == x - 1

Answer 8

您编写的每个代码都应该高效。对于像您这样的初学者，最简单的方法是检查＆＃39; n＆＃39; 从 2到（n）的可分性-1）即可。当你考虑非常大的数字时，这需要花费很多时间。平方根方法有助于我们通过较少的比较来使代码更快。阅读关于算法设计和分析中的 复杂性。

Answer 9

这是我的方法：

import math

def isPrime(n):
    'Returns True if n is prime, False if n is not prime. Will not work if n is 0 or 1'

    # Make sure n is a positive integer
    n = abs(int(n))

    # Case 1: the number is 2 (prime)
    if n == 2: return True

    # Case 2: the number is even (not prime)
    if n % 2 == 0: return False

    # Case 3: the number is odd (could be prime or not)

    # Check odd numbers less than the square root for possible factors 
    r = math.sqrt(n)
    x = 3 
    while x <= r:
        if n % x == 0: return False  # A factor was found, so number is not prime
        x += 2 # Increment to the next odd number

    # No factors found, so number is prime  
    return True

要回答原始问题， n ** 0.5 与 n 的根平方相同。您可以在此数字后停止检查因子，因为复合数字总是的因子小于或等于其平方根。这比仅仅检查每个n的2和n之间的所有因子要快，因为我们检查的数字越少，随着n的增长节省更多的时间。

Answer 10

我不知道我是否迟到了，但我会留在这里帮助将来的人。

我们使用（n）的平方根，即int（n ** 0.5）来减少程序将被强制计算的数字范围。

例如，我们可以进行试验分裂以测试100的素数。让我们看一下100的所有除数：

2,4,5,10,20,25,50 在这里我们看到最大因子是100/2 = 50.对于所有n都是如此：所有除数小于或等于n / 2。如果我们仔细研究除数，我们会看到其中一些是多余的。如果我们以不同的方式编写列表：

100 = 2×50 = 4×25 = 5×20 = 10×10 = 20×5 = 25×4 = 50×2 冗余变得明显。一旦我们达到10，即√100，除数就会翻转并重复。因此，我们可以进一步消除大于√n的测试除数。

取另一个数字，如16。

它的除数是2,4,8

16 = 2 * 8,4 * 4,8 * 2.

你可以注意到，在达到4，即16的平方根之后，我们重复了8 * 2，我们已经做了2 * 8。这种模式适用于所有数字。

为了避免重复自己，我们因此测试到数字n的平方根的素数。

因此我们将平方根转换为int，因为我们不希望带有浮点数的范围。

阅读维基百科上的素性测试以获取更多信息。

Answer 11

def is_prime(x):  
    if x < 2:  
        return False  
    for n in range(2, (x) - 1):  
        if x % n == 0:  
            return False  
    return True

Answer 12

isPrime=lambda x: all(x % i != 0 for i in range(int(x**0.5)+1)[2:])

以及如何使用它

isPrime(2) == False
isPrime(5) == True
isPrime(7) == True

要查找您可能使用的所有素数：

filter(isPrime, range(4000)[2:])[:5]
=> [2, 3, 5, 7, 11]

请注意，在这种情况下，5表示要查找的素数的数量，以及4000个最大值的范围。

Answer 13

在python中实现了伪代码（https://en.wikipedia.org/wiki/Primality_test），希望对此有所帮助。

tuple

Answer 14

def isPrime(num,div=2):
    if(num==div):
        return True
    elif(num % div == 0):
        return False
    else:
        return isPrime(num,div+1)

============================================== <登记/> EDITED

def is_prime(num, div = 2):
    if num == div: return True
    elif num % div == 0: return False
    elif num == 1: return False
    else: return is_prime(num, div + 1)

Answer 15

int(n**0.5)是sqrt（n）的底值，与n (n**2)的幂2混淆。如果n 不是素数，则必须有两个数字1 < i <= j < n，以便：i * j = n。

现在，由于sqrt(n) * sqrt(n) = n假设i,j之一大于（或等于）sqrt(n) - 这意味着另一个必须小于（或等于）{ {1}}。

既然如此，那么迭代sqrt(n)范围内的整数就足够了。而这正是发布的代码正在做的事情。

如果你想成为一个真正的智能手机，请使用以下单线功能：

[2, sqrt(n)]

可以找到“魔法正则表达式”的解释here

Answer 16

def is_prime(n):
if (n==2 or n==3): return True
if(n<=1 or n%2==0 or n%3==0 ): return False
for i in range(6,int((n**0.5)) + 2,6):
    if(n%(i-1)==0 or n%(i+1)==0):
        return False
return True

Answer 17

def fun(N):#prime test
if N>1 :
    for _ in xrange(5):
        Num=randint(1,N-1)
        if pow(Num,N-1,N)!=1:
            return False
    return True
return False

如果数字为素数则为真，否则为假

Answer 18

这是代码学院的一项练习，这就是我在下面通过它的方式...

def is_prime(x):  

    # If number(x) is evenly divided by following dividers then number(x) is not prime

    divider = [2, 3, 5, 7]

    # An empty list to be able to check whether number(x) is evenly divided:

    remainder = []

    # exceptions for numbers 1,2,3,5,7:
    if x < 2:
        return False
    if x in divider:
        return True
    else:
        for nums in divider:
            remainder.append(x % nums)
        if 0 in remainder:
            return False
        else:
            return True

Answer 19

这是np方式：

def is_prime(x):
    if x < 4:
        return True
    if all([(x > 2), (x % 2 == 0)]):
        return False
    else:
        return np.array([*map(lambda y: ((x % y) == 0).sum(), np.arange(1, x + 1))]).sum() == 2

以下是表现：

%timeit is_prime(2)
%timeit is_prime(int(1e3))
%timeit is_prime(5003)

10000 loops, best of 3: 31.1 µs per loop
10000 loops, best of 3: 33 µs per loop
10 loops, best of 3: 74.2 ms per loop

Answer 20

def is_prime(n):
    n=abs(n)
    if n<2:    #Numbers less than 2 are not prime numbers
        return "False"
    elif n==2: #2 is a prime number
        return "True"
    else:
        for i in range(2,n): # Highlights range numbers that can't be  a factor of prime number n. 
            if n%i==0:
                return "False" #if any of these numbers are factors of n, n is not a prime number
    return "True" # This is to affirm that n is indeed a prime number after passing all three tests

Answer 21

非常简单！

def prime(x):
  if x == 1:
    return False
  else:
    for a in range(2,x):
      if x % a == 0:
        return False
  return True

Answer 22

（https://www.youtube.com/watch?v=Vxw1b8f_yts&t=3384s）阿维纳什耆那教

for i in range(2,5003):
    j = 2
    c = 0
    while j < i:
        if i % j == 0:
            c = 1
            j = j + 1
        else:
            j = j + 1
    if c == 0:
        print(str(i) + ' is a prime number')
    else:
        c = 0

Answer 23

我有一个新的解决方案，我认为可能比任何提到的更快 Python中的函数

它的基础是： N / D = R. 对于任意数字N，除N（如果不是素数）的最小可能数是D = 2，相应的结果R是（N / 2）（最高）。

当D变大时，结果R变得更小ex：除以D = 3结果R =（N / 3）因此，当我们检查N是否可以被D整除时，我们也会检查它是否可以被R整除

随着D变大而R变小（D == R ==平方根（N））

然后我们只需要检查从2到sqrt（N）的数字另一个节省时间的小费，我们只需要检查奇数，因为数字可以被任何偶数整除，它也可以被2整除。

所以序列将是3,5,7,9，......，sqrt（N）。

import math
def IsPrime (n): 
    if (n <= 1 or n % 2 == 0):return False
    if n == 2:return True
    for i in range(3,int(math.sqrt(n))+1,2):
        if (n % i) == 0:
            return False
    return True

Answer 24

数字1是一种特殊情况，既不是主要的也不是复合的。有关详细信息，请访问：http://mathworld.wolfram.com/PrimeNumber.html

和，（n ** 0.5） - ＆gt;这将为我们提供'n'的“平方根”。因为它“被提升到0.5或1/2”的功率

为什么我们这样做，以数字400为例：我们可以用a * b

的形式表示它

1*400 = 400
2*200 = 400
4*100 = 400
5*80 = 400
8*50 = 400
10*40 = 400
16*25 = 400
20*20 = 400
25*16 = 400
40*10 = 400
50*8 = 400
80*5 = 400
100*4 = 400
200*2 = 400
400*1 = 400

400的平方根是20：我们可以看到，我们只需要检查可分性，直到20，因为'a'达到20'b'开始减少...... 所以，最终我们用小于平方根的数字来检查可分性。

Answer 25

这是我的

import math

def is_prime(num):

    if num % 2 == 0 and num > 2: 
       return False
    for i in range(3, int(math.sqrt(num)) + 1, 2):
        if num % i == 0:
            return False
    return True

Answer 26

def is_prime(x):  
    if x<2:  
        return False  
    elif x == 2:  
        return True  
    else:  
        for n in range(2, x):  
            if x%n==0:  
                return False  
        return True

Answer 27

Srsly的家伙...为什么这么简单的方法有这么多行代码？这是我的解决方案：

def isPrime(a):
    div = a - 1
    res = True
    while(div > 1):
        if a % div == 0:
            res = False
        div = div - 1
    return res

isPrime Python语言函数

27 个答案: