下面是一个更有趣的多行lambdas实现。这是不可能实现的，因为python使用缩进作为一种结构代码的方式。

但幸运的是，我们可以使用数组和括号禁用缩进格式。

正如一些人已经指出的，你可以这样写代码:

lambda args: (expr1, expr2,... exprN)

理论上，如果你保证从左到右求值，它是可行的，但你仍然会丢失从一个表达式传递到另一个表达式的值。

实现这个的一种方法有点啰嗦

lambda args: [lambda1, lambda2, ..., lambdaN]

每个lambda从前一个接收参数。

def let(*funcs):
    def wrap(args):
        result = args                                                                                                                                                                                                                         
        for func in funcs:
            if not isinstance(result, tuple):
                result = (result,)
            result = func(*result)
        return result
    return wrap

这个方法可以让你编写一些lisp/scheme之类的东西。

你可以这样写:

let(lambda x, y: x+y)((1, 2))

可以用一种更复杂的方法来计算斜边

lst = [(1,2), (2,3)]
result = map(let(
  lambda x, y: (x**2, y**2),
  lambda x, y: (x + y) ** (1/2)
), lst)

这将返回一个标量数字列表，因此可以使用它将多个值减少为一个。

有那么多肯定不是很有效但是如果你有约束的话，这是一个快速完成一些事情的好方法然后再把它重写成一个实际的函数。

以下是几个相关的连结:

有一段时间，我一直在跟踪Reia的开发，它最初也将在Erlang之上使用Python的基于缩进的语法和Ruby块。但是，设计师最终放弃了缩进敏感性，他写的这篇文章包括了他在缩进+多行块中遇到的问题的讨论，以及他对Guido的设计问题/决策的更多欣赏:

http://www.unlimitednovelty.com/2009/03/indentation-sensitivity-post-mortem.html

另外，这里有一个关于ruby风格的Python块的有趣建议，我遇到过Guido发布了一个响应，实际上没有将它击落(虽然不确定是否有任何后续的击落):

http://tav.espians.com/ruby-style-blocks-in-python.html

Guido van Rossum (Python的发明者)在一篇旧博客文章中亲自回答了这个问题。 基本上，他承认这在理论上是可能的，但任何提出的解决方案都是非python的:

“但对我来说，这个谜题的任何解决方案的复杂性都是巨大的:它要求解析器(或者更准确地说，词法分析器)能够在缩进敏感和不缩进模式之间来回切换，保持先前模式的堆栈和缩进水平。从技术上讲，这些问题都可以解决(已经有一堆缩进级别可以被一般化)。但这些都不能改变我的直觉，那就是这一切都是一个精心设计的鲁布·戈德堡(Rube Goldberg)的精巧装置。”

我从python开始，但来自Javascript的最明显的方式是提取表达式作为函数....

人为的例子，乘法表达式(x*2)被提取为函数，因此我可以使用multiline:

def multiply(x):
  print('I am other line')
  return x*2

r = map(lambda x : multiply(x), [1, 2, 3, 4])
print(list(r))

https://repl.it/@datracka/python-lambda-function

也许它并没有确切地回答这个问题，如果这是如何在lambda表达式本身做多行，但如果有人得到这个线程，看看如何调试表达式(像我)，我认为这将有所帮助

在Python3.8之后，还有另一个用于本地绑定的方法

lambda x: (
    y := x + 1,
    y ** 2
)[-1]

For循环

lambda x: (
    y := x ** 2,
    [y := y + x for _ in range(10)],
    y
)[-1]

如果分支

lambda x: (
    y := x ** 2,
    x > 5 and [y := y + x for _ in range(10)],
    y
)[-1]

Or

lambda x: (
    y := x ** 2,
    [y := y + x for _ in range(10)] if x > 5 else None,
    y
)[-1]

While循环

import itertools as it
lambda x: (
    l := dict(y = x ** 2),
    cond := lambda: l['y'] < 100,
    body := lambda: l.update(y = l['y'] + x),
    *it.takewhile(lambda _: cond() and (body(), True)[-1], it.count()),
    l['y']
)[-1]

Or

import itertools as it
from types import SimpleNamespace as ns
lambda x: (
    l := ns(y = x ** 2),
    cond := lambda: l.y < 100,
    body := lambda: vars(l).update(y = l.y + x),
    *it.takewhile(lambda _: cond() and (body(), True)[-1], it.count()),
    l.y
)[-1]

Or

import itertools as it
lambda x: (
    y := x ** 2,
    *it.takewhile(lambda t: t[0],
    ((
    pred := y < 100,
    pred and (y := y + x))
    for _ in it.count())),
    y
)[-1]

我只是玩了一点，试图用reduce来理解字典，并想出了这个一行hack:

In [1]: from functools import reduce
In [2]: reduce(lambda d, i: (i[0] < 7 and d.__setitem__(*i[::-1]), d)[-1], [{}, *{1:2, 3:4, 5:6, 7:8}.items()])                                                                                                                                                                 
Out[3]: {2: 1, 4: 3, 6: 5}

我只是试图做同样的事情，在这个Javascript字典理解:https://stackoverflow.com/a/11068265