blocks|key|1490803|text|首先，递归的lambda表达式是完全不必要的。正如您自己指出的，为了让lambda表达式调用自身，它需要有一个名称。但是lambda表达式只不过是匿名函数。所以如果你给lambda表达式一个名字，它不再是一个lambda表达式，而是一个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490804|因此，使用lambda表达式是没有用的，只会让人感到困惑。所以用def来创建它。|1490805|但是，正如您自己发现的那样，lambda表达式可以是递归的。你自己的例子就是。事实上，它是如此奇妙的递归，以至于你超过了最大递归深度。所以它是递归的。您的问题是，您总是在表达式中调用add，因此递归永远不会停止。别干那事。你的表达式可以这样表达：|1490806|add+=+lambda+a,+b:+a+>+0+and+(1+%2B+add(a-1,+b))+or+b|code-block|syntax|javascript|1490807|它解决了这个问题。然而，你的第一个def是正确的方式。|1490808|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

First of all recursive lambda expressions are completely unnecessary. As you yourself point out, for the lambda expression to call itself, it needs to have a name. But lambda expressions is nothing else than anonymous functions. So if you give the lambda expression a name, it's no longer a lambda expression, but a function.

Hence, using a lambda expression is useless, and will only confuse people. So create it with a def instead.

But yes, as you yourself discovered, lambda expressions can be recursive. Your own example is. It's in fact so fantastically recursive that you exceed the maximum recursion depth. So it's recursive alright. Your problem is that you always call add in the expression, so the recursion never stops. Don't do that. Your expression can be expressed like this instead:

<pre><code>add = lambda a, b: a &gt; 0 and (1 + add(a-1, b)) or b
</code></pre>

Which takes care of that problem. However, your first def is the correct way of doing it.

blocks|key|1275936|text|add+=+lambda+a,+b:+b+if+a+<=+0+else+1+%2B+add(a+-+1,+b)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1275937|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>add = lambda a, b: b if a &lt;= 0 else 1 + add(a - 1, b)
</code></pre>

blocks|key|1275958|text|也许你应该试试Z+combinator，这个例子就来自这里：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1275959|>>>+Z+=+lambda+f:+(lambda+x:+f(lambda+*args:+x(x)(*args)))(lambda+x:+f(lambda+*args:+x(x)(*args)))
>>>+fact+=+lambda+f:+lambda+x:+1+if+x+==+0+else+x+*+f(x-1)
>>>+Z(fact)(5)
120|code-block|syntax|javascript|1275960|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fixed_point_combinator^0|7|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Perhaps you should try the <a href="http://en.wikipedia.org/wiki/Fixed_point_combinator" rel="noreferrer">Z combinator</a>, where this example is from:

<pre><code>&gt;&gt;&gt; Z = lambda f: (lambda x: f(lambda *args: x(x)(*args)))(lambda x: f(lambda *args: x(x)(*args)))
&gt;&gt;&gt; fact = lambda f: lambda x: 1 if x == 0 else x * f(x-1)
&gt;&gt;&gt; Z(fact)(5)
120
</code></pre>

blocks|key|1276017|text|您需要Y组合器或其他fixed+point+combinator。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1276018|下面是一个Python+lambda表达式的示例实现：|1276019|Y+=+lambda+g:+(lambda+f:+g(lambda+arg:+f(f)(arg)))+(lambda+f:+g(lambda+arg:+f(f)(arg)))|code-block|syntax|javascript|1276020|像这样使用它：|1276021|factorial+=+Y(lambda+f:+(lambda+num:+num+and+num+*+f(num+-+1)+or+1))|1276022|也就是说，您将一个单参数函数(或lambda)传递给Y()，该函数接收自身的递归版本作为其参数。因此，函数不需要知道自己的名称，因为它获得了对自身的引用。|1276023|请注意，对于add()函数来说，这确实很棘手，因为Y组合器只支持传递单个参数。您可以通过currying获取更多参数--但我将把它留给读者作为练习。:-)|1276024|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fixed_point_combinator|1|http://en.wikipedia.org/wiki/Currying^0|A|M|0|0|0|0|0|0|0|18|8|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

You want the Y combinator, or some other <a href="http://en.wikipedia.org/wiki/Fixed_point_combinator" rel="nofollow noreferrer">fixed point combinator</a>.

Here's an example implementation as a Python lambda expression:

<pre><code>Y = lambda g: (lambda f: g(lambda arg: f(f)(arg))) (lambda f: g(lambda arg: f(f)(arg)))
</code></pre>

Use it like so:

<pre><code>factorial = Y(lambda f: (lambda num: num and num * f(num - 1) or 1))
</code></pre>

That is, you pass into Y() a single-argument function (or lambda), which receives as its argument a recursive version of itself. So the function doesn't need to know its own name, since it gets a reference to itself instead.

Note that this does get tricky for your add() function because the Y combinator only supports passing a single argument. You can get more arguments by <a href="http://en.wikipedia.org/wiki/Currying" rel="nofollow noreferrer">currying</a> -- but I'll leave that as an exercise for the reader. :-)

blocks|key|1490950|text|有点晚了..。但是我刚刚找到了这个宝石@+http://metapython.blogspot.com/2010/11/recursive-lambda-functions.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1490951|def+myself+(*args,+**kw):
++++caller_frame+=+currentframe(1)
++++code+=+caller_frame.f_code
++++return++FunctionType(code,+caller_frame.f_globals)(*args,**kw)

print+"5!+=+"
print+(lambda+x:1+if+n+<=+1+else+myself(n-1)*n)(5)|code-block|syntax|javascript|1490952|entityMap|0|LINK|mutability|MUTABLE|url|http://metapython.blogspot.com/2010/11/recursive-lambda-functions.html^0|L|1Y|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

a little late ... but I just found this gem @ <a href="http://metapython.blogspot.com/2010/11/recursive-lambda-functions.html" rel="nofollow">http://metapython.blogspot.com/2010/11/recursive-lambda-functions.html</a>

<pre><code>def myself (*args, **kw):
 caller_frame = currentframe(1)
 code = caller_frame.f_code
 return FunctionType(code, caller_frame.f_globals)(*args,**kw)

print "5! = "
print (lambda x:1 if n &lt;= 1 else myself(n-1)*n)(5)
</code></pre>

I'm trying to write a lambda-expression that calls itself, but i can't seem to find any syntax for that, or even if it's possible.

Essentially what I wanted to transfer the following function into the following lambda expression: (I realize it's a silly application, it just adds, but I'm exploring what I can do with lambda-expressions in python)

<pre><code>def add(a, b):
 if a &lt;= 0:
 return b
 else:
 return 1 + add(a - 1, b)

add = lambda a, b: [1 + add(a-1, b), b][a &lt;= 0]
</code></pre>

but calling the lambda form of add results in a runtime error because the maximum recursion depth is reached. Is it even possible to do this in python? Or am I just making some stupid mistake? Oh, I'm using python3.0, but I don't think that should matter?

recursive lambda-expressions possible?

Python

我正在尝试编写一个调用自身的lambda表达式，但我似乎找不到任何语法来实现这一点，或者即使它是可能的。实际上，我想将以下函数转换为下面的lambda表达式：(我意识到这是一个愚蠢的应用程序，它只是添加了一些内容，但我正在探索如何在python中使用lambda表达式)def add(a, b): if a <= ...

问递归的lambda表达式可能吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问递归的lambda表达式可能吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问递归的lambda表达式可能吗？
EN