Python语言的isPrime函数

因此，我能够通过互联网上的一点帮助来解决这个问题，这就是我得到的：

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

但我的问题是怎么做，为什么。我知道1不被视为“素数”，即使它是，而且我知道如果它被范围内的任何东西除，它自动不是素数，因此返回错误语句。但是我的问题是，支持“n”的方在这里扮演什么角色

---

P.S.P.S.我很缺乏经验，一个月前刚被介绍给编程。

< >在Internet上漂浮的许多素数测试中，请考虑下面的Python函数：

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)
  # since all primes > 3 are of the form 6n ± 1
  # start with f=5 (which is prime)
  # and test f, f+2 for being prime
  # then loop by 6. 
  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    

import re
def is_prime(n):    
    return not re.match(r'^1?$|^(11+?)\1+$',n*'1')

印刷品：

 5
 11
 17
 23
 29
 35
 41
 47
 53
 59
 65
True

行

r=int（n**0.5）

计算为70（5003的平方根为70.7318881411，

int（）

截断该值）

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

 5
False

极限是平方根，因为函数只需执行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的奇数来稍微加快它的速度

因此：

---

---

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

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

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

def为素数（n）：
“”前提条件：n是非负整数
post条件：如果n为素数，则返回True，否则返回False。”“”
如果n<2：
返回False；
如果n%2==0：
返回n==2#返回False
k=3
当k*k与
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）只有一个因子，它本身。因此，它不符合这个定义。
找到数字的平方根是为了提高效率。例如，如果我试图找到36的因子，那么可以乘以它自身形成36的最高数字是6.7*7=49

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

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

=============================================================

编辑

def为素数（x）：
如果x
def为素数（x）：
如果x<2：
返回错误
elif x==2：
返回真值
对于范围（2，x）内的n：
如果x%n==0：
返回错误
返回真值
Srsly伙计们……为什么像这样一个简单的方法需要这么多行代码？我的解决方案如下：

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

下面介绍如何使用它

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

要查找所有可能使用的素数，请执行以下操作：

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

请注意，在这种情况下，5表示要查找的素数的数目和要查找素数的最大范围。
int（n**0.5）
是sqrt（n）的下限值，您将其与n的幂2（n**2）
混淆。如果
n
不是素数，则必须有两个数
1def是素数（x）：
如果x<2：
返回错误
对于范围（2，（x）-1）内的n：
如果x%n==0：
返回错误
返回真值
非常简单

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

这个问题刚问过，但我有一个简短的解决方案

def isNotPrime(Number):
    return 2 not 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

反例：

2^341%341=2,  but 341==11*31
2^561%561=2,  but 561==3*11*17
2^645%645=2,  but 645==3*5*43

如果数字不是素数，isNotPrime（）可靠地返回True。
您编写的每一个代码都应该是有效的。对于像您这样的初学者来说，最简单的方法是检查数字从'n'到2到（n-1）的整除性当你考虑非常大的数字时，需要花费大量的时间。平方根方法有助于我们通过较少的比较来加快代码的速度。阅读关于设计和分析算法的强>复杂性。< /强> 
 < P>这是我的

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

如果数字为prime，则为True，否则为false，我不知道我是否迟到了，但我会把这个留在这里，以便将来帮助别人

我们使用（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
冗余bec
filter(isPrime, range(4000)[2:])[:5]
=> [2, 3, 5, 7, 11]

import re
def is_prime(n):    
    return not re.match(r'^1?$|^(11+?)\1+$',n*'1')

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

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

def isNotPrime(Number):
    return 2 not in [Number,2**Number%Number]

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

2^341%341=2,  but 341==11*31
2^561%561=2,  but 561==3*11*17
2^645%645=2,  but 645==3*5*43

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

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

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

from math import factorial

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

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 

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

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

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

# original pseudocode https://en.wikipedia.org/wiki/Primality_test
def isPrime(n):
    # Corner Cases
    if (n<= 1): return False
    elif (n<= 3): return True
    elif (n%2 == 0 or n%3 == 0): return False

    i = 5
    while i*i<=n:
        if (n%i==0 or n%(i+2)==0): return False
        i += 6

    return True;

%timeit isPrime(800)

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

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

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