Python 我的代码的递归不'；即使我把所有的东西都退了，我也似乎不起作用

我正在编写代码来检查一个数字是否为素数，但我希望参数同时为list和integer。为此，我使用递归，但递归似乎不起作用

 def prime_checker(suspected_prime):
    if type(suspected_prime) == type(list()):
        result_list = list()
        for x in range(len(suspected_prime)):
            result_list.append(prime_checker(suspected_prime[x]))
        return(result_list)
    else:
        prime_factor, factors, suspected_prime = 2, 0, abs(suspected_prime)
        while factors < 1:
            if suspected_prime % prime_factor == 0:
                factors += 1
            if math.ceil(suspected_prime**0.5) == prime_factor:
                if factors == 0:
                    return True
                else:
                    return False
            prime_factor += 1 

def prime_checker（可疑的_prime）：
如果类型（怀疑的_素数）=类型（列表（））：
结果列表=列表（）
对于范围内的x（len（怀疑_素数））：
结果列表。追加（素数检查器（可疑素数[x]））
返回（结果列表）
其他：
素数因子，因子，可疑素数=2，0，绝对值（可疑素数）
当系数<1时：
如果怀疑\u素数%prime\u因子==0：
系数+=1
如果math.ceil（可疑素数**0.5）=素数因子：
如果系数==0：
返回真值
其他：
返回错误
素数因子+=1

我认为这应该适用于您的代码：

def prime(suspected_prime):
if type(suspected_prime) == list:
    result_list = list()
    for x in suspected_prime:
        result_list.append(prime(x))
    return(result_list)
else:
    factors,suspected_prime = 0,abs(suspected_prime)
    root = int(suspected_prime**0.5)
    for x in range (2,(root+1)):
        if(factors == 1):
            break
        elif(suspected_prime%x == 0):
            factors = 1  
            return False

    if (factors == 0):
        return True

---

如果需要，可以根据需要更改if-else语句

您的

列表

案例和

int

案例都太复杂了，如果不打破的话，让我们看看我们能做些什么。首先，使用

isinstance

测试类型。接下来，您不需要循环索引，您可以更轻松地循环内容

至于

int

子句，在知道答案后，您可以继续进行数学运算——对于素数，不要这样浪费时间。此外，如果我们将数字2及以下和偶数视为特例，并且只关注奇数除数的测试，则这种素数测试方式通常更简单：

def prime_checker(suspected_primes):
    if isinstance(suspected_primes, list):
        return [prime_checker(entity) for entity in suspected_primes]

    suspected_prime = abs(suspected_primes)

    if suspected_prime < 2:
        return False

    if suspected_prime % 2 == 0:
        return suspected_prime == 2

    for divisor in range(3, int(suspected_prime**0.5) + 1, 2):
        if suspected_prime % divisor == 0:
            return False

    return True

print(prime_checker([1, [2, 3], 4, [5, 6, [7, 8], 9]]))
print(prime_checker(13))

目前您有：

def prime-checker (input could be scalar or a list)

策略1：（删除质数检查器中的循环，始终处理标量，即非列表）。所以你有：

def prime_checker (scalar, ie. non-list input arg) :

要处理此问题，请将实现更改为始终处理标量。在主要检查器功能外部执行循环。有了这个，你的质数检查器将只有数学计算部分，所以它将更简单，更容易理解

战略2： 或者，如果您坚持让列表在主检查器中循环

案例1：如果你的输入只是一个数字，比如45。然后将输入参数作为[45]发送 因此，prime checker的外部调用（来自外部调用方）将变为

results = prime_checker( [45])

案例2：如果您的输入是一个列表，比如list1，那么您的调用是

results = prime_checker (list1).

因此，现在您的实现总是期望并处理一个列表

# we always get input as a list (hence I changed the arg name)
 def prime_checker(suspected_list):
    # this branch *looks* recursive, but actually only handles a list
    if (len(suspected_list) > 1) :
        result_list = []
        for prime_candidate in suspected_list:
            result_list.append(prime_checker([prime_candidate]) # recur, as a list
        return(result_list)
    else: (when suspected list has only 1 entry)
        # this branch does the actual prime calculation for a single input
        suspected_prime = suspected_list[0]
        prime_factor, factors, suspected_prime = 2, 0, abs(suspected_prime)
        while factors < 1:
            if suspected_prime % prime_factor == 0:
                factors += 1
            if math.ceil(suspected_prime**0.5) == prime_factor:
                if factors == 0:
                    return True
                else:
                    return False
            prime_factor += 1 

#我们总是以列表的形式获取输入（因此我更改了arg名称）
def prime_检查器（可疑_列表）：
#这个分支*看起来*递归，但实际上只处理一个列表
如果（len（可疑清单）>1）：
结果_列表=[]
对于可疑候选人名单中的主要候选人：
result_list.append（prime_checker（[prime_candidate]）#作为列表重复出现
返回（结果列表）
其他：（当可疑列表只有一个条目时）
#此分支对单个输入执行实际的基本计算
可疑\u素数=可疑\u列表[0]
素数因子，因子，可疑素数=2，0，绝对值（可疑素数）
当系数<1时：
如果怀疑\u素数%prime\u因子==0：
系数+=1
如果math.ceil（可疑素数**0.5）=素数因子：
如果系数==0：
返回真值
其他：
返回错误
素数因子+=1

代码中存在问题。在函数中传递列表后，它将使用素数检查程序（怀疑的素数[x]）重新运行，然后它将检查类型（怀疑的素数）=类型（列表（））。作为类型（任何的素数[x]是整数，它将不会重新运行。@ak47hil您最好将其作为答案而不是注释发布，它太大且太小unreadable@mangusta我不确定这是否是代码的唯一问题，但乍看之下，这似乎是问题所在。这就是为什么我以注释的形式回答它。我确信这不是完整的答案。@ak47hil当if条件重新运行时，这s time prime是一个整数，那么else条件不应该运行吗？我只面临这个问题。当递归时，它不会进入else条件。在

return

语句之后有两个语句将永远不会执行。您可以抛出

factors

变量和与之相关的所有逻辑——最终的test只是变成了一个

返回True

。我已经更正了代码以包含您的更正。Break语句仍然应该运行，因为它将中断循环流，并且与返回无关。如我所建议的那样，通过不丢弃

因子，您使代码变得更复杂，而不是更好。是的，我将删除因子您是对的。但是，即使是您的问题的具体实现是只为一个数字创建一个质数检查器，然后使用map函数在列表中迭代。代码将更加清晰，结果将与您认真计算不变的
math.ceil（怀疑质数**0.5）
在循环中一遍又一遍？如果你做了
factors+=1
你知道答案是
False
，为什么要画出来？（为什么要使用
factors
）您的twisted实现模糊了您的有趣之处，即区分长度为1的列表和更长的列表，作为处理列表与标量的替代方案。我没有尝试更正或优化素数计算。OP在递归调用中遇到了问题。我只是建议以不同的方式组织代码。我不会尝试要点是：在递归调用中，您希望将输入参数保持为一致的数据类型。此外，递归调用始终有一个基数（零）案例-在OP的实现中，基本案例是输入数据类型从列表变为标量。我将基本案例替换为长度为1的列表。我发现了问题。谢谢！
# we always get input as a list (hence I changed the arg name)
 def prime_checker(suspected_list):
    # this branch *looks* recursive, but actually only handles a list
    if (len(suspected_list) > 1) :
        result_list = []
        for prime_candidate in suspected_list:
            result_list.append(prime_checker([prime_candidate]) # recur, as a list
        return(result_list)
    else: (when suspected list has only 1 entry)
        # this branch does the actual prime calculation for a single input
        suspected_prime = suspected_list[0]
        prime_factor, factors, suspected_prime = 2, 0, abs(suspected_prime)
        while factors < 1:
            if suspected_prime % prime_factor == 0:
                factors += 1
            if math.ceil(suspected_prime**0.5) == prime_factor:
                if factors == 0:
                    return True
                else:
                    return False
            prime_factor += 1