Question

def numb_fact(number): 
    factor_list = []
    for d in range(2, number+1, 1):
        if number % d == 0:
            factor_list.append(d)
        else:
            pass
    return factor_list
def factorize(number):

    allfact_list = numb_fact(number)
    final_list = []
    if len(allfact_list) > 0:
        d = allfact_list[0]
        if number % d == 0:
            final_list.append(d)
            divided_numb = int(number / d)
            factorize(divided_numb)
        else:
            if len(allfact_list) > 1:
                allfact_list.remove(d)
            else:
                return final_list
        print(final_list)
    return final_list

factorize(12)

Sample output
[3]
[2]
[2]

因此，我正在编写代码以显示质数倍数的数字。为此，我想从创建一个给我“数字列表”的函数开始，如果列表中的所有数字都相乘，它将形成原始数字。

我认为编写此代码的唯一方法是递归，暂时暂不考虑代码效率（因为我知道它看起来很糟糕）-我编写的此函数不会在factor_list中保留值。（很明显！因为我正在重新启动代码，其最初定义为'= []'）因此，我一直在想了好几个小时，是否有一种方法可以在单个函数中解决这个问题。

Answer 1

我不知道您为什么首先生成因素，然后递归检查。没有必要。

使用递归时，请尝试不要在递归函数中定义变量，然后返回它。正如您自己提到的那样，它每次都会重置，因此仅保留其中的最后一个值。

但是，这是如何在代码中保留值的方法：

def numb_fact(number): 
    factor_list = []
    for d in range(2, number+1, 1):
        if number % d == 0:
            factor_list.append(d)
        else:
            pass
    return factor_list
def factorize(number):

    allfact_list = numb_fact(number)
    if len(allfact_list) > 0:
        d = allfact_list[0]
        if number % d == 0:
            divided_numb = int(number / d)
            return [d] + factorize(divided_numb)
    else:
        return []
print(factorize(12))

这是我想到的另一个简短/更好的递归解决方案。

def factor(num,div = 2):
    if num != 1:
        if num%div==0:
            return [div] + (factor(num/div,div))
        else:
            return (factor(num,div+1))

    else:
        return []
print(factor(12))

输出：[2，2，3]

Answer 2

我知道我没有直接回答您的问题。但是出于您的目的，您根本不需要使用递归。简单的迭代就足够了。

class PrimeGenerator:
    def __init__(self):
        self.current=2 # 1 is not prime number

    def __iter__(self):
        while True:
            for n in range(2,int(self.current**0.5)+1):
                if self.current%n==0: # checking if it's not prime
                    break
            else:
                yield self.current
            self.current+=1

    def reset(self):
        self.current=1 # because the generator increases by one after it hits yield

def factorize(n):
    generator=PrimeGenerator()
    result=[]
    for prime in generator:
        if n%prime==0:
            result.append(prime)
            n//=prime
            generator.reset()
        if n==1:
            break
    return result

print(factorize(12))

我知道有更好的算法来检查素数，但是除非您要处理的数非常大，否则此实现足够快。

如何在递归中保留价值

2 个答案: