Python 遍历数字<；n、 确定每个数字'；s素因子分解

我想遍历 我知道我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以，我可以。我在下面写了一个实现，从所有小于N的素数因子中生成每个小于N的数。有没有更快的方法？我试图利用这样一个事实，因为我对小于N的所有数字都这样做是为了节省计算时间，而不是使用试除法

我努力实现的目标是： 我有一个算法，我想在每个小于N的数上运行。对于这个算法，我需要每个数的素数分解。我试图在最短的时间内得到每个数的素因子分解。我实际上不需要存储素数分解，我只需要用素数分解运行我的算法。（算法在代码中为solve（curNum，curFactors）

我写了一个python3程序，用它的素数的知识递归地生成每个数字，但是速度非常慢。（当N=10^7时，需要约58秒的处理时间。函数solve对此基准测试不做任何操作。）

curFactors是一个列表，其中每个偶数元素都是因子分解中素数的索引，每个奇数元素都是素数的指数。为了节省计算时间，我将它从列表中展平。基本开始索引用于确保我不会重复计算数字。目前Solve什么都不做，只是为了让我可以对这个函数进行基准测试

def iterateThroughNumbersKnowingFactors(curNumber, curFactors, primeStartIndex):
    #Generate next set of numbers
    #Handle multiplying by a prime already in the factorization seperately.
    for i in range(primeStartIndex+1,lenPrimes):
        newNum = curNumber * primelist[i]
        if(newNum > upperbound):
            break
        newFactors = curFactors[:]
        newFactors.append(i)
        newFactors.append(1)
        #Do something with this number and its factors
        solve(newNum, newFactors)
        #Go get more numbers
        iterateThroughNumbersKnowingFactors(newNum,newFactors,i)
    if(primeStartIndex > -1):
        newNum = curNumber * primelist[primeStartIndex]
        if(newNum > upperbound):
            return
        currentNumPrimes = len(curFactors)
        curFactors[currentNumPrimes-1] += 1
        #Do something with this number and its factors
        solve(newNum, curFactors)
        #Go get more numbers
        iterateThroughNumbersKnowingFactors(newNum,curFactors,primeStartIndex)

upperbound = 10**7

#https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n
primelist = primesfrom2to(upperbound+1)
lenPrimes = len(primelist)

t0 = time.clock()
iterateThroughNumbersKnowingFactors(1,[],-1)
print(str(time.clock() - t0) +" seconds process time")

---

有人知道更好的方法吗？

如果您已经实施了埃拉托斯烯筛，并且其性能可以接受，那么您可以修改它以存储主要因子

---

基本方法是这样的：无论何时，只要你想“划掉”一个数字或将其从素数的倍数列表中删除，就要检查你能将它除以素数而不带余数的次数（使用

/

和

%

）。这将给你们一个（素数，指数）对，代表素数分解的那个部分。将这些对存储在与原始编号关联的列表或字典中。当筛选完成后，每个列表都将描述相应数字的素因子分解。

如果您想玩得开心，可以使用在

O（log（N））

时间间隔

[1，N]

中生成一个随机数。重复此操作直到找到小于N的所有数字的素因式分解在理论上可能需要无限时间，但算法的预期运行时间将是

O（log^2（N））

---

这可能有点效率损失，但如果你想要一个有趣的算法，它不会以线性顺序迭代，那么这可能是你最好的选择：）

利用埃拉托斯尼筛的灵感，你可以通过将素数传播到一个素数因子列表（最多N个）来构建因子列表：

要仅知道存在哪些素数，请执行以下操作：

def primeFactors(N):
    result = [[] for _ in range(N+1)]  # lists of factors from 0..N
    for p in range(1,N+1,2):
        if p<2: p=2 
        if result[p]: continue         # empty list is a prime 
        for k in range(p,len(result),p):
                result[k].append(p)    # propagate it to all multiples
    return result

print(*enumerate(primeFactors(10)))
# (0, []) (1, []) (2, [2]) (3, [3]) (4, [2]) (5, [5]) (6, [2, 3]) (7, [7]) (8, [2]) (9, [3]) (10, [2, 5])

def参数（N）：
结果=[]用于范围内（N+1）]的系数列表，从0..N
对于范围（1，N+1,2）内的p：
如果你能更清楚地解释一下你到底想做什么？您想生成一个整数列表，其中包含该列表索引值的素因式分解，并达到某个限制？很抱歉不清楚。我有一个算法，我想在每个小于N的数上运行。对于这个算法，我需要每个数的素数分解。我的问题是，对于每一个小于N的数字，最快的方法是什么。我实际上不需要将素数分解存储在内存中，我只需要使用素数分解运行算法。例如：
primes=[]；对于范围内的i（上界）：primes.append（prime\u factorization（i））
本质上就是您要做的事情？那么，您正在寻找一个优化的Python素数分解实现？是的！我正在努力寻找一种更优化的方法。任何语言的答案都很好，我可以将其转换为Python。我不知道还有什么比我现在做的更优化的方法。还有我的错误，谢谢你指出。我已经编辑了答案以更正它。我认为我描述的方法需要粗心的N log N实现；迭代筛选内部循环中的两个变量。一个加素数，另一个加一。
def primeFactorsAll(N):
    result = [[] for _ in range(N+1)]
    for p in range(1,N+1,2):
        if p<2: p=2
        if result[p]: continue
        pn = p
        while pn < N:
            for k in range(pn,len(result),pn): # propagate to multiples of
                result[k].append(p)            # each power of p
            pn *= p
    return result

print(*enumerate(primeFactorsAll(10)))
# (0, []) (1, []) (2, [2]) (3, [3]) (4, [2, 2]) (5, [5]) (6, [2, 3]) (7, [7]) (8, [2, 2, 2]) (9, [3, 3]) (10, [2, 5])