如果没有其他条件，这是递归的

Question

我刚开始学习python。我遇到了lambda函数。在其中一个问题上，作者要求为一个数字的阶乘写一个单线性lambda函数。

这是给出的解决方案：

num = 5
print (lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b > 0 else 1,b))(num)

我无法理解奇怪的语法。（a，b）是什么意思？

有人可以解释一下吗？

由于

Answer 1

阶乘本身几乎和你期望的一样。你推断a是......阶乘函数。 b是实际参数。

<factorial> = lambda a, b: b*a(a, b-1) if b > 0 else 1

这一位是阶乘的应用：

<factorial-application> = (lambda a, b: a(a, b))(<factorial>, b)

a是因子函数本身。它将自己作为第一个参数，将评估点作为第二个参数。只要您不介意recursive_lambda而不是a(a, b - 1)，这可以推广到a(b - 1)：

recursive_lambda = (lambda func: lambda *args: func(func, *args))
print(recursive_lambda(lambda self, x: x * self(self, x - 1) if x > 0 else 1)(6))
# Or, using the function verbatim:
print(recursive_lambda(lambda a, b: b*a(a, b-1) if b > 0 else 1)(6))

所以我们有外部部分：

(lambda b: <factorial-application>)(num)

如您所见，调用者必须通过的是评估点。

如果实际上想要一个递归的lambda，你可以name the lambda：

fact = lambda x: 1 if x == 0 else x * fact(x-1)

如果没有，您可以使用a simple helper function。您会注意到ret是一个可以引用自身的lambda，与之前没有lambda可以引用自身的代码不同。

def recursive_lambda(func):
    def ret(*args):
        return func(ret, *args)
    return ret

print(recursive_lambda(lambda factorial, x: x * factorial(x - 1) if x > 1 else 1)(6))  # 720

无论如何，你都不必诉诸于将lambda传递给自己的荒谬手段。

Answer 2

让我们将这一个衬里剥开，就像洋葱一样。

print (lambda b: (Y))(num)

我们正在创建一个匿名函数（关键字lambda意味着我们将要键入一系列参数名称，然后是冒号，然后是使用这些参数的函数），然后传递num以满足其一个参数。< / p>

   (lambda a, b: a(a, b))(X,b)

在lambda中，我们定义了另一个lambda。调用这个lambda Y.这个有两个参数，a和b。 a用a和b调用，所以a是一个可调用的，它自己和另一个参数

            (lambda a, b: b*a(a, b-1) if b > 0 else 1
            ,
            b)

这些是Y的参数。第一个是lambda函数，称之为X.我们可以看到X是阶乘函数，第二个参数将成为它的数字。

也就是说，如果我们上去查看Y，我们可以看到我们会打电话：

X(X, b)

将会做

b*X(X, b-1) if b > 0 else 1

并自称，形成阶乘的递归部分。

一直看着外面，我们可以看到b是我们传入最外面的lambda的数字。

num*X(X, b-1) if num > 0 else 1

这有点令人困惑，因为它被写成一个令人困惑的一个班轮：）

Answer 3

就是这么简单：

n=input()

print reduce(lambda x,y:x*y,range(1,n+1))

Answer 4

这个功能有两个难点 1. lambda a, b: b*a(a, b-1) if b > 0 else 1。
2.下面的“b”1。

对于1，它只不过是：

def f(a, b):
    if b > 0:
        b * a(a, b - 1)
    else:
        1

2，这个b

(lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b > 0 else 1,b))(num)
                                                                      (this one)

实际上就是这个b：

(lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b > 0 else 1,b))(num)
   (this one)

原因是它不在第二和第三个lambda的定义范围内，所以它指的是第一个b。

在我们应用num并剥离外部函数之后：

(lambda a, b: a(a, b))  (lambda a, b: b*a(a, b-1) if b > 0 else 1, num)

它只是将一个函数应用于元组，（lambda a，b：b * a（a，b-1），如果b> 0，则为1，num）
让我们把这个元组称为（f，num）（f的def在上面）在其上应用lambda a, b: a(a, b)，我们得到

f（f，num）。

假设你的数字为5 根据f的定义，它首先评估为

5 * f(f, 4)

然后到：

5 * (4 * f(f, 3))

一直到

5 * (4 * (3 * (2 * (1 * f(f, 0)))))

f（f，0）变为1.

5 * (4 * (3 * (2 * (1 * 1))))

我们走了，阶乘5。

Answer 5

我们可以使用下面的lambda表达式

     fact = lambda n:1 if n==0 else n*fact(n-1)
     print(fact(5)
     >>> 120

Answer 6

递归lambda的广义def如下所示

recursive_lambda = (lambda func: lambda *args: func(func, *args))

Answer 7

非常好解释！只有一个小修复：如果b> 1不是b> 0

结果相同但在逻辑上更正确，因为它正在执行一个不必要的额外循环（即使乘以1）

Wikipedia =＆gt; n！是所有小于或等于n

的正整数的乘积

Answer 8

如果要使用lambda表达式进行阶乘，则需要放置if条件，例如：

if x==1: 
    return 1 
else 
    return x*function_name(x-1)

例如fact是我的lambda表达式：

fact( lambda x:1 if x==1/else x*fact(x-1) )

如果没有其他条件，这是递归的

Answer 9

使用Lambda函数轻松查找阶乘的方法

fac = lambda x : x * fac(x-1) if x > 0 else 1

print(fac(5))

输出： 120

用户输入以查找阶乘

def fac():

    fac_num = int(input("Enter Number to find Factorial "))

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

    print(factorial(fac_num))

fac()

输入数字以查找因子：5

120

Answer 10

相关代码：

lambda b : (lambda a, b : a(a, b)) (lambda a, b : b * a(a, b-1) if b > 0 else 1,  b)

为了更加清楚，让我replace variable names a with f, and b with n。

lambda n : (lambda f, n : f(f, n)) (lambda f, n : n * f(f, n-1) if n > 0 else 1,  n)

递归阶乘是一个将调用自身或应用于自身的函数，例如f（f）。让我们设置Factorial(n) to be f(f,n)并进行如下计算：

def func(f, n):  # takes a function and a number, return a number.
        if n > 0 :
            return n * f(f, n-1)
        else :
            return 1

将上述def函数转换为lambda表示法：

func is     lambda f, n : n * f(f, n-1) if n > 0 else 1

然后将

func与整数n一起应用于自身。

回到开头的语句，Factorial(n) is f(f,n), or f(func,n) when func is applied into f.

def Factorial(n):  
    # return f (func, n)  # next, substitute f and func with their corresponding lambdas.
    return (lambda f, n : f(f, n))  (lambda f, n : n * f(f, n-1) if n > 0 else 1, n)

并使用lambda代替def Factorial，整个过程变为：

lambda n : (lambda f, n : f(f, n)) (lambda f, n : n * f(f, n-1) if n > 0 else 1, n)

Answer 11

while True: 
    #It is this simple:
    from functools import reduce
    n=input('>>')
    n=int(n)
    if n==0:
        print('factorial: ',1)
    elif n<0:
        print('invalid input')
    else:
        print('factorial: ',(reduce(lambda x,y:x*y,list(range(1,n+1)))))

Python lambda函数计算一个数的阶乘

11 个答案:

如果没有其他条件，这是递归的