Question

我想做一个循环，使阶乘从10到1。

所以我有这段代码：

factorial = 1
for i in range(1,11):
    factorial = factorial * i
    print(i,'!=', factorial)

但这显示了这样的结果：

1 != 1
2 != 2
3 != 6

但是我想要他们这样：

10 != 3628800
9 != 362880
8 != 40320

我尝试了几种不同的方法，但是没有真正起作用，请问任何想法吗？

Answer 1

results = []
factorial = 1
for i in range(1,11):
    factorial = factorial * i
    results.append('{:2,}! = {:,}'.format(i, factorial))

print('\n'.join(reversed(results)))

输出：

10! = 3,628,800
 9! = 362,880
 8! = 40,320
 7! = 5,040
 6! = 720
 5! = 120
 4! = 24
 3! = 6
 2! = 2
 1! = 1

要减少所需的内存量，可以改成这样：

results = []
factorial = 1
for i in range(1, 11):
    factorial *= i
    results.append(factorial)

for i, value in enumerate(reversed(results)):
    print('{:2,}! = {:,}'.format(len(results)-i, value))

如果您喜欢列表推导，也可以通过这种有点古怪的方式来完成：

res = []
res = [res[-1] for x in range(1, 11) if not res.append(x*res[-1] if res else 1)]

for i, value in enumerate(reversed(res)):
    print('{:2,}! = {:,}'.format(len(res)-i, value))

Answer 2

要计算10!，首先需要计算9!，因此，避免冗余计算的最佳方法是编写一个计算阶乘1!的函数/生成器， 2!，...，然后反转结果。

例如，

>>> def factorials(n):
...:    fact = 1
...:    for i in range(1, n+1):
...:        fact = fact*i
...:        yield fact
...:        
>>> n = 10
>>> facts = reversed(list(factorials(n)))
>>>
>>> for f, i in zip(facts, range(n, 0, -1)):
...:    print('{}! = {}'.format(i, f))
...:    
10! = 3628800
9! = 362880
8! = 40320
7! = 5040
6! = 720
5! = 120
4! = 24
3! = 6
2! = 2
1! = 1

Answer 3

将任务分为计算和输出。将计算出的值存储在字典中，以供以后输出。将数字存储在字典中要便宜一些，然后再存储所有输出字符串以备后用-仍然如此，如果您要计算很高的阶乘，最终将使您得到的内存溢出。

通过逐步填充字典，您可以重用上次创建的阶乘，从而减少了计算的复杂性。

通过这种方式，您可以在打印所有因子时进行出价：

# calculation:
f = {}
for i in range(1,11):

    # the i-th factorial is equal to the (i-1)-th factorial multiplied by i
    # for f[1] you try to access f[0] which does not exists, hence we use the 
    # default value:   dict.get(key, defaultvalue_used_if_key_not_in_dict)
    f[i] = f.get((i-1),1) * i

# different ways of output:
sor = sorted(f,reverse=True)
# print top down
for key in sor:
    print(f"{key:>2}! == {f[key]}")

# top down, only even
for key in sor:
    if key % 2 == 0:
        print(f"{key:>2}! == {f[key]}")

# top down, only odd    
for key in sor:
    if key % 2 == 1:
        print(f"{key:>2}! == {f[key]}")

print(f)

输出：

10! == 3628800
 9! == 362880
 8! == 40320
 7! == 5040
 6! == 720
 5! == 120
 4! == 24
 3! == 6
 2! == 2
 1! == 1

10! == 3628800
 8! == 40320
 6! == 720
 4! == 24
 2! == 2

 9! == 362880
 7! == 5040
 5! == 120
 3! == 6
 1! == 1

# f 
{1: 1, 2: 2, 3: 6, 4: 24, 5: 120, 6: 720, 7: 5040, 8: 40320, 9: 362880, 10: 3628800}

请参阅：python.org Dict-Doku

Answer 4

如果您确定要以这种方式计算阶乘，则想到的唯一方法是将输出插入到list \ dictionary，并在计算后将其打印出来。

factorial = 1
factList = {}
for i in range(1,11):
    factorial = factorial * i
    factList[i] = factorial

for i in range(1,11):
    print(11-i, "!: ",factList[11-i])

Answer 5

第一：
对于python中的阶乘，我们可以使用math.factorial() math — Mathematical functions

第二：
您希望您的列表以reversed的顺序排列。

所以我们只使用递减的for循环for i in range(x, 0, -1):
-1是我们正在使用的步骤，x是您的起点，0是循环的结尾。

第三：
使用生成器节省内存。
在这种情况下，我正在使用yield The Python yield keyword explained

最后：
您可以使用for loop

打印出生成器

代码示例：

import math

def fact(x):
    for i in range(x, 0, -1):
        yield math.factorial(i)

results = fact(10)

for num in results:
    print(num)

向后打印阶乘？

5 个答案: