blocks|key|1641210|text|不使用reduce，map，命名为lambdas或python内部：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1641211|(lambda+a:lambda+v:a(a,v))(lambda+s,x:1+if+x==0+else+x*s(s,x-1))(10)|code-block|syntax|javascript|1641212|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

without reduce, map, named lambdas or python internals:

<pre><code>(lambda a:lambda v:a(a,v))(lambda s,x:1 if x==0 else x*s(s,x-1))(10)
</code></pre>

blocks|key|1641097|text|你不能直接这么做，因为它没有名字。但是使用像Lemmy所指的Y-combinator这样的辅助函数，您可以通过将函数作为参数传递给自身来创建递归(尽管这听起来很奇怪)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1641098|#+helper+function
def+recursive(f,+*p,+**kw):
+++return+f(f,+*p,+**kw)

def+fib(n):
+++#+The+rec+parameter+will+be+the+lambda+function+itself
+++return+recursive((lambda+rec,+n:+rec(rec,+n-1)+%2B+rec(rec,+n-2)+if+n>1+else+1),+n)

#+using+map+since+we+already+started+to+do+black+functional+programming+magic
print+map(fib,+range(10))|code-block|syntax|javascript|1641099|这将打印前十个斐波纳契数：[1,+1,+2,+3,+5,+8,+13,+21,+34,+55]，|offset|length|style|CODE|1641100|entityMap^0|0|0|D|Y|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can't directly do it, because it has no name. But with a helper function like the Y-combinator Lemmy pointed to, you can create recursion by passing the function as a parameter to itself (as strange as that sounds):

<pre><code># helper function
def recursive(f, *p, **kw):
 return f(f, *p, **kw)

def fib(n):
 # The rec parameter will be the lambda function itself
 return recursive((lambda rec, n: rec(rec, n-1) + rec(rec, n-2) if n&gt;1 else 1), n)

# using map since we already started to do black functional programming magic
print map(fib, range(10))
</code></pre>

This prints the first ten Fibonacci numbers: <code>[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]</code>,

blocks|key|1426262|text|是。我有两种方法，其中一种已经介绍过了。这是我更喜欢的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426263|(lambda+v:+(lambda+n:+n+*+__import__('types').FunctionType(
++++++++__import__('inspect').stack()[0][0].f_code,+
++++++++dict(__import__=__import__,+dict=dict)
++++)(n+-+1)+if+n+>+1+else+1)(v))(5)|code-block|syntax|javascript|1426264|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yes. I have two ways to do it, and one was already covered. This is my preferred way.

<pre><code>(lambda v: (lambda n: n * __import__('types').FunctionType(
 __import__('inspect').stack()[0][0].f_code, 
 dict(__import__=__import__, dict=dict)
 )(n - 1) if n &gt; 1 else 1)(v))(5)
</code></pre>

blocks|key|1641386|text|这个答案非常简单。这比雨果·沃尔特的答案简单一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1641387|>>>+(lambda+f:+f(f))(lambda+f,+i=0:+(i+<+10)and+f(f,+i+%2B+1)or+i)
10
>>>|code-block|syntax|javascript|1641388|雨果·沃尔特的回答是：|1641389|(lambda+a:lambda+v:a(a,v))(lambda+s,x:1+if+x==0+else+x*s(s,x-1))(10)|1641390|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This answer is pretty basic. It is a little simpler than Hugo Walter's answer:

<pre><code>&gt;&gt;&gt; (lambda f: f(f))(lambda f, i=0: (i &lt; 10)and f(f, i + 1)or i)
10
&gt;&gt;&gt;
</code></pre>

Hugo Walter's answer:

<pre><code>(lambda a:lambda v:a(a,v))(lambda s,x:1 if x==0 else x*s(s,x-1))(10)
</code></pre>

blocks|key|1426083|text|我从来没有用过Python，但是this可能就是你要找的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1426084|entityMap|0|LINK|mutability|MUTABLE|url|http://siddhi.blogspot.com/2007/08/y-combinator-in-python.html^0|G|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I have never used Python, but <a href="http://siddhi.blogspot.com/2007/08/y-combinator-in-python.html" rel="noreferrer">this</a> is probably what you are looking for.

blocks|key|1426569|text|def+recursive(def_fun):
++++def+wrapper(*p,+**kw):
++++++++fi+=+lambda+*p,+**kw:+def_fun(fi,+*p,+**kw)
++++++++return+def_fun(fi,+*p,+**kw)

++++return+wrapper


factorial+=+recursive(lambda+f,+n:+1+if+n+<+2+else+n+*+f(n+-+1))
print(factorial(10))

fibonaci+=+recursive(lambda+f,+n:+f(n+-+1)+%2B+f(n+-+2)+if+n+>+1+else+1)
print(fibonaci(10))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1426570|希望能对某些人有所帮助。|unstyled|1426571|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>def recursive(def_fun):
 def wrapper(*p, **kw):
 fi = lambda *p, **kw: def_fun(fi, *p, **kw)
 return def_fun(fi, *p, **kw)

 return wrapper


factorial = recursive(lambda f, n: 1 if n &lt; 2 else n * f(n - 1))
print(factorial(10))

fibonaci = recursive(lambda f, n: f(n - 1) + f(n - 2) if n &gt; 1 else 1)
print(fibonaci(10))
</code></pre>

Hope it would be helpful to someone.

blocks|key|1426707|text|顺便说一句，不是费波纳奇的缓慢计算：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426708|f+=+lambda+x:+1+if+x+in+(1,2)+else+f(x-1)%2Bf(x-2)|code-block|syntax|javascript|1426709|我建议快速计算斐波纳契数：|1426710|fib+=+lambda+n,+pp=1,+pn=1,+c=1:+pp+if+c+>+n+else+fib(n,+pn,+pn%2Bpp,+c%2B1)|1426711|它真的很快。|1426712|这里还有阶乘计算：|1426713|fact+=+lambda+n,+p=1,+c=1:+p+if+c+>+n+else+fact(n,+p*c,+c%2B1)|1426714|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

By the way, instead of slow calculation of Fibonacci:

<pre><code>f = lambda x: 1 if x in (1,2) else f(x-1)+f(x-2)
</code></pre>

I suggest fast calculation of Fibonacci:

<pre><code>fib = lambda n, pp=1, pn=1, c=1: pp if c &gt; n else fib(n, pn, pn+pp, c+1)
</code></pre>

It works really fast.

Also here is factorial calculation:

<pre><code>fact = lambda n, p=1, c=1: p if c &gt; n else fact(n, p*c, c+1)
</code></pre>

blocks|key|1426446|text|嗯，不完全是纯lambda递归，但它适用于您只能使用lambda的地方，例如reduce、映射和列表理解，或其他lambda。诀窍是受益于列表理解和Python的名称作用域。下面的示例通过给定的键链遍历字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426447|>>>+data+=+{'John':+{'age':+33},+'Kate':+{'age':+32}}
>>>+[fn(data,+['John',+'age'])+for+fn+in+[lambda+d,+keys:+None+if+d+is+None+or+type(d)+is+not+dict+or+len(keys)+<+1+or+keys[0]+not+in+d+else+(d[keys[0]]+if+len(keys)+==+1+else+fn(d[keys[0]],+keys[1:]))]][0]
33|code-block|syntax|javascript|1426448|lambda重用了在列表理解表达式(fn)中定义的名称。该示例相当复杂，但它展示了概念。|1426449|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Well, not exactly pure lambda recursion, but it's applicable in places, where you can only use lambdas, e.g. reduce, map and list comprehensions, or other lambdas. The trick is to benefit from list comprehension and Python's name scope. The following example traverses the dictionary by the given chain of keys.

<pre><code>&gt;&gt;&gt; data = {'John': {'age': 33}, 'Kate': {'age': 32}}
&gt;&gt;&gt; [fn(data, ['John', 'age']) for fn in [lambda d, keys: None if d is None or type(d) is not dict or len(keys) &lt; 1 or keys[0] not in d else (d[keys[0]] if len(keys) == 1 else fn(d[keys[0]], keys[1:]))]][0]
33
</code></pre>

The lambda reuses its name defined in the list comprehension expression (fn). The example is rather complicated, but it shows the concept.

blocks|key|1426797|text|我知道这是一个老帖子，但它在一些谷歌搜索结果中排名很高:)。随着python3.8的到来，您可以使用walrus运算符以更少的语法实现Y-combinator！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426798|fib+=+(lambda+f:+(rec+:=+lambda+args:+f(rec,+args)))\
++++++(lambda+f,+n:+n+if+n+<=+1+else+f(n-2)+%2B+f(n-1))|code-block|syntax|javascript|1426799|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I know this is an old thread, but it ranks high on some google search results :). With the arrival of python 3.8 you can use the walrus operator to implement a Y-combinator with less syntax!
<pre class="lang-py prettyprint-override"><code>fib = (lambda f: (rec := lambda args: f(rec, args)))\
 (lambda f, n: n if n &lt;= 1 else f(n-2) + f(n-1))
</code></pre>

blocks|key|1641700|text|我们现在可以使用新的python语法来使它变得更短、更容易阅读：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1641701|斐波那契数：|1641702|>>>+(f:=lambda+x:+1+if+x+<=+1+else+f(x+-+1)+%2B+f(x+-+2))(5)
8|code-block|syntax|javascript|1641703|阶乘：|1641704|>>>+(f:=lambda+x:+1+if+x+==+0+else+x*f(x+-+1))(5)
120|1641705|我们使用:=来命名lambda:直接在lambda本身中使用该名称，并立即将其作为匿名函数调用。|offset|length|style|CODE|1641706|(参见https://www.python.org/dev/peps/pep-0572)|1641707|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0572^0|0|0|0|0|0|4|2|0|3|14|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@$O|18|P|19|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@$O|1B|P|1C|1|1D]]|A|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

We can now use new python syntax to make it way shorter and easier to read:
Fibonacci:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; (f:=lambda x: 1 if x &lt;= 1 else f(x - 1) + f(x - 2))(5)
8
</code></pre>
Factorial:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; (f:=lambda x: 1 if x == 0 else x*f(x - 1))(5)
120
</code></pre>
We use <code>:=</code> to name the lambda: use the name directly in the lambda itself and call it right away as an anonymous function.
(see <a href="https://www.python.org/dev/peps/pep-0572" rel="nofollow noreferrer">https://www.python.org/dev/peps/pep-0572</a>)

blocks|key|1426640|text|Lambda可以很容易地替换Python中的递归函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426641|例如，这个基本的compound_interest：|1426642|def+interest(amount,+rate,+period):
++++if+period+==+0:+
++++++++return+amount
++++else:
++++++++return+interest(amount+*+rate,+rate,+period+-+1)|code-block|syntax|javascript|1426643|可以替换为：|1426644|lambda_interest+=+lambda+a,r,p:+a+if+p+==+0+else+lambda_interest(a+*+r,+r,+p+-+1)|1426645|或者为了获得更多的可见性：|1426646|lambda_interest+=+lambda+amount,+rate,+period:+\
amount+if+period+==+0+else+\
lambda_interest(amount+*+rate,+rate,+period+-+1)|1426647|用法：|1426648|print(interest(10000,+1.1,+3))
print(lambda_interest(10000,+1.1,+3))|1426649|输出：|1426650|13310.0
13310.0|1426651|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Lambda can easily replace recursive functions in Python:

For example, this basic compound_interest:

<pre><code>def interest(amount, rate, period):
 if period == 0: 
 return amount
 else:
 return interest(amount * rate, rate, period - 1)
</code></pre>

can be replaced by:

<pre><code>lambda_interest = lambda a,r,p: a if p == 0 else lambda_interest(a * r, r, p - 1)
</code></pre>

or for more visibility :

<pre><code>lambda_interest = lambda amount, rate, period: \
amount if period == 0 else \
lambda_interest(amount * rate, rate, period - 1)
</code></pre>

USAGE:

<pre><code>print(interest(10000, 1.1, 3))
print(lambda_interest(10000, 1.1, 3))
</code></pre>

Output:

<pre><code>13310.0
13310.0
</code></pre>

blocks|key|1426821|text|就像这样简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1426822|fac+=+lambda+n:+1+if+n+<=+1+else+n*fac(n-1)|code-block|syntax|javascript|1426823|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As simple as:
<pre class="lang-py prettyprint-override"><code>fac = lambda n: 1 if n &lt;= 1 else n*fac(n-1)
</code></pre>

blocks|key|1641153|text|如果你是一个真正的受虐狂，你也许可以使用C扩展来做到这一点，但是回应Greg+(嗨Greg!)，这超出了lambda+(未命名的，匿名的)函数的能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1641154|不是的。(对于no的大多数值)。|1641155|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you were truly masochistic, you might be able to do it using C extensions, but to echo Greg (hi Greg!), this exceeds the capability of a lambda (unnamed, anonymous) functon.

No. (for most values of no).

A regular function can contain a call to itself in its definition, no problem. I can't figure out how to do it with a lambda function though for the simple reason that the lambda function has no name to refer back to. Is there a way to do it? How?

Can a lambda function call itself recursively in Python?

一个常规函数可以在其定义中包含对自身的调用，这是没有问题的。我不知道如何使用lambda函数来实现这一点，原因很简单，lambda函数没有可以引用的名称。有办法做到这一点吗？多么?

问在Python中，lambda函数可以递归地调用自己吗？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中，lambda函数可以递归地调用自己吗？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中，lambda函数可以递归地调用自己吗？
EN