我的代码在python中通过递归查找素数是否正确？答案是什么？

我正在学习由约翰·亨特先生写的《Python 3入门指南》一书中的Python。在第8章中，关于递归，有一个练习，需要一个通过递归找到素数的代码。我独立编写了下面的第一个代码，但答案键是用不同的结构编写的。因为我对递归非常怀疑，你对这两个问题的分析是什么？哪个更递归

我的代码：

def is_prime(n, holder = 1):
    if n == 2:
        return True
    else:
        if (n-1 + holder)%(n-1) == 0:
            return False
        else:
            return is_prime(n-1, holder+1)

print('is_prime(9):', is_prime(9))
print('is_prime(31):', is_prime(31))

def is_prime(n, i=2):
    # Base cases
    if n <= 2:
        return True if (n == 2) else False
    if n % i == 0:
        return False
    if i * i > n:
        return True

    # Check for next divisor
    return is_prime(n, i + 1)

print('is_prime(9):', is_prime(9))
print('is_prime(31):', is_prime(31))

应答键：

def is_prime(n, holder = 1):
    if n == 2:
        return True
    else:
        if (n-1 + holder)%(n-1) == 0:
            return False
        else:
            return is_prime(n-1, holder+1)

print('is_prime(9):', is_prime(9))
print('is_prime(31):', is_prime(31))

def is_prime(n, i=2):
    # Base cases
    if n <= 2:
        return True if (n == 2) else False
    if n % i == 0:
        return False
    if i * i > n:
        return True

    # Check for next divisor
    return is_prime(n, i + 1)

print('is_prime(9):', is_prime(9))
print('is_prime(31):', is_prime(31))

def为素数（n，i=2）：
#基本情况
如果n：
返回真值
#检查下一个除数
返回值为_素数（n，i+1）
print（'is_prime（9）：'，is_prime（9））
print（'is_prime（31）：'，is_prime（31））

是的，您的示例似乎工作正常。但是请注意，根据实现的性质，答案键更有效。为了验证数字n是否为素数，您的算法最多使用n-1个函数调用，而提供的答案在达到sqrt（n）的迭代计数后停止。检查较大的数字通常没有意义，因为如果n可以被a>sqrt（n）值除而不带余数，那么它也必须被b=n%a除

---

此外，由于没有定义0的模，您的代码在n=1时产生了一个计算异常。

是的，您的示例似乎工作正常。但是请注意，根据实现的性质，答案键更有效。为了验证数字n是否为素数，您的算法最多使用n-1个函数调用，而提供的答案在达到sqrt（n）的迭代计数后停止。检查较大的数字通常没有意义，因为如果n可以被a>sqrt（n）值除而不带余数，那么它也必须被b=n%a除

---

此外，由于没有定义0的模，您的代码在n=1时产生了一个计算异常。

在这种情况下，我的建议是完全不要使用递归。虽然我知道您想将此作为如何使用递归的学习示例，但学习何时使用递归也很重要

def is_prime(n):
    
    if n == 2:
        return True

    i = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += 1

    return True

递归有一个允许的最大深度，因为递归越深，需要放在上的项就越多。因此，这不是一个使用递归的好例子，因为在这种情况下很容易达到最大值。即使是“模型”示例代码也会遇到这种情况。确切的最大递归深度可能取决于实现，但例如，如果我尝试使用它来计算

is_prime（1046527）

，则会得到一个错误：

RecursionError: maximum recursion depth exceeded while calling a Python object

插入一个

print（i）

语句表明，当

i=998

时会遇到它

“模型”示例的简单非递归等价物将不会有此问题。（有更有效的解决方案，但这一方案除了不使用递归外，还试图与模型解决方案保持距离。）

def为素数（n）：
如果n==2：
返回真值
i=2
在这种情况下，我的建议是根本不要使用递归。虽然我知道您想将此作为如何使用递归的学习示例，但学习何时使用递归也很重要

def is_prime(n):
    
    if n == 2:
        return True

    i = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += 1

    return True

递归有一个允许的最大深度，因为递归越深，需要放在上的项就越多。因此，这不是一个使用递归的好例子，因为在这种情况下很容易达到最大值。即使是“模型”示例代码也会遇到这种情况。确切的最大递归深度可能取决于实现，但例如，如果我尝试使用它来计算
is_prime（1046527）
，则会得到一个错误：

RecursionError: maximum recursion depth exceeded while calling a Python object

插入一个
print（i）
语句表明，当
i=998
时会遇到它

“模型”示例的简单非递归等价物将不会有此问题。（有更有效的解决方案，但这一方案除了不使用递归外，还试图与模型解决方案保持距离。）

def为素数（n）：
如果n==2：
返回真值
i=2
我想说，回答键需要改进。我们可以加快速度，更干净地处理基本情况：

def is_prime(n, i=3):
    # Base cases
    if n < 2:
        return False

    if n % 2 == 0:
        return n == 2

    if i * i > n:
        return True

    if n % i == 0:
        return False

    # Check for next divisor
    return is_prime(n, i + 2)

def为素数（n，i=3）：
#基本情况
如果n<2：
返回错误
如果n%2==0：
返回n==2
如果i*i>n：
返回真值
如果n%i==0：
返回错误
#检查下一个除数
返回值为_素数（n，i+2）

原来的答案键从2开始，然后按1递增——这里我们从3开始，然后按2递增

就你的答案而言，有一个不同的缺陷需要考虑。Python的默认堆栈深度是1000帧，而您的函数在输入1000帧以上不久就会失败。上述解决方案更节省地使用递归，在达到Python的默认堆栈限制之前，可以处理高达4000000的输入。
我认为应答键需要改进。我们可以加快速度，更干净地处理基本情况：

def is_prime(n, i=3):
    # Base cases
    if n < 2:
        return False

    if n % 2 == 0:
        return n == 2

    if i * i > n:
        return True

    if n % i == 0:
        return False

    # Check for next divisor
    return is_prime(n, i + 2)

def为素数（n，i=3）：
#基本情况
如果n<2：
返回错误
如果n%2==0：
返回n==2
如果i*i>n：
返回真值
如果n%i==0：
返回错误
#检查下一个除数
返回值为_素数（n，i+2）

原来的答案键从2开始，然后按1递增——这里我们从3开始，然后按2递增

就你的答案而言，有一个不同的缺陷需要考虑。Python的默认堆栈深度是1000帧，而您的函数在输入1000帧以上不久就会失败。上面的解决方案更节省地使用递归，在达到Python的默认堆栈限制之前，可以处理高达4000000的输入。
我花了一些时间来理解您的代码，这暗示它可以改进。。。但它是有效的