因为lambda函数应该是单行的，作为函数的最简单形式，一个入口，然后返回

让我试着解决@balpha解析问题。我会用圆括号括住多行。如果没有括号，lambda定义是贪婪的。所以in

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

返回一个函数，返回(y*z， [1,2,3])

But

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

意味着

map(func, [1,2,3])

func是返回y*z的多行lambda。这有用吗?

下面是一个更有趣的多行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)

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

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

我知道这是一个老问题，但是为了记录，这里有一种多行lambda问题的解决方案，其中一个调用的结果被另一个调用消耗。

我希望它不是超级hack，因为它只是基于标准库函数，没有使用dunder方法。

下面是一个简单的例子，我们从x = 3开始，然后在第一行加1，然后在第二行加2，得到6作为输出。

from functools import reduce

reduce(lambda data, func: func(data), [
    lambda x: x + 1,
    lambda x: x + 2
], 3)

## Output: 6

以下是几个相关的连结:

有一段时间，我一直在跟踪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

让我也说说我对不同变通方法的看法。

一个简单的单行lambda与普通函数有什么不同?我能想到的只有缺少赋值，一些类似循环的结构(for, while)， try-except子句……就这样?我们甚至有一个三元运算符——酷!那么，让我们试着解决每一个问题。

作业

这里的一些人正确地指出，我们应该看看lisp的let表单，它允许本地绑定。实际上，所有不改变状态的赋值都只能用let来执行。但是每一个lisp程序员都知道let形式绝对等价于调用lambda函数!这意味着

(let ([x_ x] [y_ y])
  (do-sth-with-x-&-y x_ y_))

和

((lambda (x_ y_)
   (do-sth-with-x-&-y x_ y_)) x y)

所以绰绰有余!每当我们想要做一个新的赋值时我们只要添加另一个并调用它。想想这个例子:

def f(x):
    y = f1(x)
    z = f2(x, y)
    return y,z

lambda版本如下:

f = lambda x: (lambda y: (y, f2(x,y)))(f1(x))

如果您不喜欢在数据上的操作之后写入数据，您甚至可以创建let函数。你甚至可以咖喱它(只是为了更多的括号:))

let = curry(lambda args, f: f(*args))
f_lmb = lambda x: let((f1(x),), lambda y: (y, f2(x,y)))
# or:
f_lmb = lambda x: let((f1(x),))(lambda y: (y, f2(x,y)))

# even better alternative:
let = lambda *args: lambda f: f(*args)
f_lmb = lambda x: let(f1(x))(lambda y: (y, f2(x,y)))

到目前为止一切顺利。但如果我们必须进行重新分配，也就是改变状态呢?我认为我们完全可以在不改变状态的情况下快乐地生活只要任务不涉及循环。

循环

虽然循环没有直接的lambda替代，但我相信我们可以编写相当通用的函数来满足我们的需求。看看这个斐波那契函数:

def fib(n):
    k = 0
    fib_k, fib_k_plus_1 = 0, 1
    while k < n:
        k += 1
        fib_k_plus_1, fib_k = fib_k_plus_1 + fib_k, fib_k_plus_1
    return fib_k

显然，用是不可能的。但在写了一个小而有用的函数之后，我们就完成了这个和类似的情况:

def loop(first_state, condition, state_changer):
    state = first_state
    while condition(*state):
        state = state_changer(*state)
    return state

fib_lmb = lambda n:\
            loop(
              (0,0,1),
              lambda k, fib_k, fib_k_plus_1:\
                k < n,
              lambda k, fib_k, fib_k_plus_1:\
                (k+1, fib_k_plus_1, fib_k_plus_1 + fib_k))[1]

当然，如果可能的话，应该总是考虑使用map、reduce和其他高阶函数。

Try-except和其他控制结构

解决这类问题的一般方法似乎是使用惰性求值，用不接受参数的lambdas替换代码块:

def f(x):
    try:    return len(x)
    except: return 0
# the same as:
def try_except_f(try_clause, except_clause):
    try: return try_clause()
    except: return except_clause()
f = lambda x: try_except_f(lambda: len(x), lambda: 0)
# f(-1) -> 0
# f([1,2,3]) -> 3

当然，这不是try-except子句的完全替代，但您总是可以使它更通用。顺便说一句，有了这种方法，你甚至可以让if表现得像函数!

总结一下:这是很自然的，所有提到的东西都感觉有点不自然，不那么美丽。尽管如此，它还是有效的!没有任何评价和其他技巧，所以所有的智能感知将工作。我也不是说你应该在任何地方都使用它。通常你最好定义一个普通的函数。我只是证明了没有什么是不可能的。