10

如何将这两个函数组合成一个递归函数以获得此结果：

factorial(6)

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

这是我的阶乘函数的当前代码：

def factorial(n):
   if n < 1:   # base case
       return 1
   else:
       return n * factorial(n - 1)  # recursive call


def fact(n):
   for i in range(1, n+1 ):
       print "%2d! = %d" % (i, factorial(i))

此代码产生的输出如下：

fact(6)

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

如您所见，这两个函数的执行给了我正确的答案，但我只是想将这两个函数简化为一个递归函数。

4

14 回答 14

30

我们可以将这两个函数组合成一个递归函数：

def factorial(n):
   if n < 1:   # base case
       return 1
   else:
       returnNumber = n * factorial(n - 1)  # recursive call
       print(str(n) + '! = ' + str(returnNumber))
       return returnNumber
于 2010-12-21T18:13:08.343 回答
26

2行代码：

def fac(n):
    return 1 if (n < 1) else n * fac(n-1)

测试它：

print fac(4)

结果：

24
于 2014-05-06T17:52:30.450 回答
7 
def factorial(n):
    result = 1 if n <= 1 else n * factorial(n - 1)
    print '%d! = %d' % (n, result)
    return result
于 2010-12-21T18:12:56.443 回答
5

一个简短的：

def fac(n):
    if n == 0:
        return 1
    else:
        return n * fac(n-1)
print fac(0)
于 2012-12-17T22:29:51.470 回答
4

我没有使用 Python 的经验，但是像这样？

def factorial( n ):
   if n <1:   # base case
       return 1
   else:
       f = n * factorial( n - 1 )  # recursive call
       print "%2d! = %d" % ( n, f )
       return f
于 2010-12-21T18:11:02.907 回答
4

试试这个：

def factorial( n ):
   if n <1:   # base case
       print "%2d! = %d" % (n, n)
       return 1
   else:
       temp = factorial( n - 1 )
       print "%2d! = %d" % (n, n*temp)
       return n * temp  # recursive call

我注意到的一件事是，对于 n<1，您将返回“1”，这意味着即使对于负数，您的函数也会返回 1。你可能想解决这个问题。

于 2010-12-21T18:11:56.190 回答
3

这是作业吗？

def traced_factorial(n):
  def factorial(n):
    if n <= 1:
      return 1
    return n * factorial(n - 1)
  for i in range(1, n + 1):
    print '%2d! = %d' %(i, factorial(i))

阅读 PEP227以了解更多详细信息。简而言之，Python 允许您在函数中定义函数。

于 2010-12-21T18:14:05.457 回答
2 
fac = lambda x: 1 if x == 0 else x * fac(x - 1)
于 2016-03-04T10:13:02.743 回答
1

多一个

def fact(x):
    if x in {0, 1}:
        return 1
    else:
        return x * fact(x-1)

for x in range(0,10):
    print '%d! = %d' %(x, fact(x))
于 2011-07-21T20:49:36.647 回答
0

我真的不知道负数的阶乘，但这适用于所有 n >= 0：

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

    return 'error'
于 2017-06-28T14:50:21.557 回答
0

可以用这4行代码...

   def factorial(n):
        f = lambda n: n * f(n - 1) if n > 1 else 1

        for x in range(n):
            print('{}! = {}'.format(x + 1, factorial(x + 1)))
于 2018-06-04T21:27:58.717 回答
0

并且第一次使用递归和 while 循环计算阶乘。

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

虽然TrebledJ在关于使用的评论中写的选项if更好。因为while循环执行的操作 ( SETUP_LOOP, POP_BLOCK) 比if. 该功能较慢。

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

时间 -n 10000 -r 10

  • while每个循环 836 µs ± 11.8 µs
  • if每个循环 787 µs ± 7.22 µs
于 2018-11-13T13:09:56.523 回答
-1

递归函数中总是存在某种循环，以及一些停止循环的停止代码：

public int recursivefactorial(int number)
{
    if(number==1)
        return 1;
    else
        return recursivefactorial(number-1)*number;
}

如您所见，满足if条件会导致代码实际结束“循环”，这是递归函数中最重要的部分。相反，else条件部分导致recursivefactorial再次调用函数，这实际上是一种循环。

于 2019-04-25T06:05:38.370 回答
-2

再来一张=）

#FAC calculation

def fakulteta(x):
    if x!=1:
         return x*fakulteta(x-1)
    return 1


print (fakulteta(12))
于 2018-04-23T11:37:10.533 回答