如何在递归中保留值

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))

这是我提出的另一个简短/更好的递归解决方案。在

^{pr2}$

Output : [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))

我知道有更好的算法来检查质数，但是除非你处理的是非常大的数，否则这个实现已经足够快了。在