我想知道列出一个数字的所有整数因子的最佳方法，给定一个包含素因子及其指数的字典。
例如，如果我们有 {2:3, 3:2, 5:1} (2^3 * 3^2 * 5 = 360)
然后我可以写：
for i in range(4):
for j in range(3):
for k in range(1):
print 2**i * 3**j * 5**k
但是在这里我有 3 个可怕的 for 循环。给定任何分解作为字典对象参数，是否可以将其抽象为一个函数？
【问题讨论】：
我有blogged about this，最快的纯python（没有itertools）来自Tim Peters 到python 列表的帖子，并使用嵌套递归生成器：
def divisors(factors) :
"""
Generates all divisors, unordered, from the prime factorization.
"""
ps = sorted(set(factors))
omega = len(ps)
def rec_gen(n = 0) :
if n == omega :
yield 1
else :
pows = [1]
for j in xrange(factors.count(ps[n])) :
pows += [pows[-1] * ps[n]]
for q in rec_gen(n + 1) :
for p in pows :
yield p * q
for p in rec_gen() :
yield p
请注意，它的编写方式是一个素因数列表，而不是字典，即[2, 2, 2, 3, 3, 5] 而不是{2 : 3, 3 : 2, 5 : 1}。
【讨论】：
在 Python 2.6 中使用 itertools.product：
#!/usr/bin/env python
import itertools, operator
def all_factors(prime_dict):
series = [[p**e for e in range(maxe+1)] for p, maxe in prime_dict.items()]
for multipliers in itertools.product(*series):
yield reduce(operator.mul, multipliers)
例子：
print sorted(all_factors({2:3, 3:2, 5:1}))
输出：
[1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 18, 20, 24, 30, 36, 40, 45, 60,
72, 90, 120, 180, 360]
【讨论】：
product() 的纯 Python 实现。这只是 6 行代码。
嗯，不仅你有 3 个循环，而且如果你有超过 3 个因素，这种方法将不起作用:)
一种可能的方式：
def genfactors(fdict):
factors = set([1])
for factor, count in fdict.iteritems():
for ignore in range(count):
factors.update([n*factor for n in factors])
# that line could also be:
# factors.update(map(lambda e: e*factor, factors))
return factors
factors = {2:3, 3:2, 5:1}
for factor in genfactors(factors):
print factor
此外，您可以避免在内部循环中重复一些工作：如果您的工作集是 (1,3)，并且想要应用于 2^3 因子，我们正在这样做：
(1,3) U (1,3)*2 = (1,2,3,6)(1,2,3,6) U (1,2,3,6)*2 = (1,2,3,4,6,12)(1,2,3,4,6,12) U (1,2,3,4,6,12)*2 = (1,2,3,4,6,8,12,24)看看我们在第二组中有多少重复项？
但我们可以这样做：
(1,3) + (1,3)*2 = (1,2,3,6)(1,2,3,6) + ((1,3)*2)*2 = (1,2,3,4,6,12)(1,2,3,4,6,12) + (((1,3)*2)*2)*2 = (1,2,3,4,6,8,12,24)没有集合的解决方案看起来更好：
def genfactors(fdict):
factors = [1]
for factor, count in fdict.iteritems():
newfactors = factors
for ignore in range(count):
newfactors = map(lambda e: e*factor, newfactors)
factors += newfactors
return factors
【讨论】：
是的。当你有一个算法需要 n 个嵌套的 for 循环时，你通常可以把它变成一个递归函数：
def print_factors(d, product=1):
if len(d) == 0: # Base case: we've dealt with all prime factors, so
print product # Just print the product
return
d2 = dict(d) # Copy the dict because we don't want to modify it
k,v = d2.popitem() # Pick any k**v pair from it
for i in range(v+1): # For all possible powers i of k from 0 to v (inclusive)
# Multiply the product by k**i and recurse.
print_factors(d2, product*k**i)
d = {2:3, 3:2, 5:1}
print_factors(d)
【讨论】：
基本上，您在这里拥有的是一个集合，由目标数的每个因素组成。在您的示例中，该集合为{2 2 2 3 3 5}。该集合的每个严格子集都是您的数字的一个因数的因式分解，因此如果您可以生成该集合的所有子集，则可以将每个子集的元素相乘并获得所有整数除数。
从那里代码应该很明显：生成一个包含分解的列表，生成该列表的所有子集（使用生成器的奖励点；我认为标准库中有一个相关的函数）。然后乘以从那里去。无论如何都不是最佳效率，但看起来很漂亮。
【讨论】：