因子在Python中的功能

Question

如何在Python中计算整数的阶乘？

Answer 1

最简单的方式：math.factorial(x)（2.6及以上版本）。

如果您想/必须自己编写，请使用something like

def factorial(n):return reduce(lambda x,y:x*y,[1]+range(1,n+1))

或更具可读性的东西：

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

与往常一样，Google是您的朋友;）

Answer 2

在Python 2.6及更高版本中，尝试：

import math
math.factorial(n)

Answer 3

不是必需的，因为这是一个老线程。但我在这里做的是另一种使用while循环计算整数阶乘的方法。

def factorial(n):
    num = 1
    while n >= 1:
        num = num * n
        n = n - 1
    return num

Answer 4

现有解决方案

最短也可能是最快的解决方案是：

from math import factorial
print factorial(1000)

建立自己的

您还可以构建自己的解决方案。一般来说，你有两种方法。最适合我的是：

from itertools import imap
def factorial(x):
    return reduce(long.__mul__, imap(long, xrange(1, x + 1)))

print factorial(1000)

（当结果变为long时）

，它也可用于更大的数字

实现同样目标的第二种方式是：

def factorial(x):
    result = 1
    for i in xrange(2, x + 1):
        result *= i
    return result

print factorial(1000)

Answer 5

def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)

Answer 6

如果您使用的是Python2.5或更早版本，请尝试

from operator import mul
def factorial(n):
    return reduce(mul, range(1,n+1))

对于较新的Python，数学模块中存在factorial，如其他答案所示

Answer 7

使用for循环计算阶乘的另一种方法 -

def factorial(n):
    base = 1
    for i in range(n,0,-1):
        base = base * i
    print base

Answer 8

http://www.google.com/search?aq=0&oq=factorial+py&sourceid=chrome&ie=UTF-8&q=factorial+python

import math
math.factorial( yourInt )

Answer 9

出于性能原因，请不要使用递归。这将是灾难性的。

def fact(n, total=1):
    while True:
        if n == 1:
            return total
        n, total = n - 1, total * n

检查运行结果

cProfile.run('fact(126000)')

4 function calls in 5.164 seconds

使用堆栈很方便（如递归调用），但需要付出代价：存储详细信息会占用大量内存。

如果堆栈很高，则表示计算机存储了大量有关函数调用的信息。

该方法只占用常量内存（如迭代）。

或使用for循环

def fact(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

检查运行结果

cProfile.run('fact(126000)')

4 function calls in 4.708 seconds

或使用内置函数math

def fact(n):
    return math.factorial(n)

检查运行结果

cProfile.run('fact(126000)')

5 function calls in 0.272 seconds

Answer 10

你的意思是：

def fact(n):
  f = 1
  for i in range(1, n +1):
   f *= i
  return f

Answer 11

def factorial(n):
    result = 1
    i = n * (n -1)
    while n >= 1:
        result = result * n
        n = n - 1
    return result

print (factorial(10)) #prints 3628800

Answer 12

我知道已经回答了这个问题，但这是另一种具有反向范围列表理解的方法，使范围更易于阅读和紧凑：

    #   1. Ensure input number is an integer by attempting to cast value to int
    #       1a. To accomplish, we attempt to cast the input value to int() type and catch the TypeError/ValueError 
    #           if the conversion cannot happen because the value type is incorrect
    #   2. Create a list of all numbers from n to 1 to then be multiplied against each other 
    #       using list comprehension and range loop in reverse order from highest number to smallest.
    #   3. Use reduce to walk the list of integers and multiply each against the next.
    #       3a. Here, reduce will call the registered lambda function for each element in the list.
    #           Reduce will execute lambda for the first 2 elements in the list, then the product is
    #           multiplied by the next element in the list, and so-on, until the list ends.

    try :
        num = int( num )
        return reduce( lambda x, y: x * y, [n for n in range(num, 0, -1)] )

    except ( TypeError, ValueError ) :
        raise InvalidInputException ( "Input must be an integer, greater than 0!" )

您可以在以下要点中查看完整版本的代码：https://gist.github.com/sadmicrowave/d4fbefc124eb69027d7a3131526e8c06

Answer 13

这是我的尝试

>>> import math
>>> def factorial_verbose(number):
...     for i in range(number):
...             yield f'{i + 1} x '
...
>>> res = ''.join([x for x in factorial_verbose(5)])
>>> res = ' '.join([res[:len(res)-3], '=', str(math.factorial(5))])
>>> res
'1 x 2 x 3 x 4 x 5 = 120'

Answer 14

单行，快速且大数也适用：

#use python3.6.x for f-string
fact = lambda x: globals()["x"] if exec(f'x=1\nfor i in range(1, {x+1}):\n\tx*=i', globals()) is None else None

Answer 15

很多这些方法都非常好但我会说你最好的选择是使用内置功能。但是如果你想看看发生了什么，你自己会有一些非常容易创造的。我想出的一个快速的就像这里的许多人一样。

def factorial(n):
    x = 1
    li = list(range(1, n + 1))
    for each in li:
        x = x * each
    print(x)

这是一个相当高效的代码，其优点是如果你不想操作列表中的某些数据就会创建一个列表，尽管我不确定为什么你真的会这样做。

---

编辑：只是看到我把它发布在一件旧东西上。遗憾。

Answer 16

另一种方法是使用如下所示的np.prod：

def factorial(n):
    if n == 0:
        return 1
    else:
         return np.prod(np.arange(1,n+1))

Answer 17

正整数n的

Factorial ，由n！表示，是所有小于或等于n的正整数的乘积。

公式：n! = n * (n-1) * (n-2) * (n-3) * (n-4) * ....... * 1

有几种方法可以通过使用内置函数/库等在python中找到阶乘。在这里，我参考了阶乘的基本定义创建了用户定义的函数。

def factorial(n):
    fact = 1
    for i in range(1,n+1):
        fact = fact * i
    return(fact)

print(factorial(4))

我们还可以使用recursive技术来实现阶乘函数，如下所示。但是此方法仅对较小的整数有效。因为在递归中，该函数会被重复调用并需要一个内存空间来维护堆栈，这对于大整数值查找阶乘而言不是一种有效或优化的方法。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(4))

Answer 18

def factorial(n):
mul = 1
for i in range( 1, n + 1):
    mul *= i
print(factorial(6))

Answer 19

非递归解决方案，无导入：

def factorial(x):
    return eval(' * '.join(map(str, range(1, x + 1))))