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

如果lambda函数有多行，可以简单地使用斜杠(\)

例子:

mx = lambda x, y: x if x > y \
     else y
print(mx(30, 20))

Output: 30

我知道这是一个老问题，但是为了记录，这里有一种多行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

我从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表达式本身做多行，但如果有人得到这个线程，看看如何调试表达式(像我)，我认为这将有所帮助

让我给你介绍一个光荣但可怕的技巧:

import types

def _obj():
  return lambda: None

def LET(bindings, body, env=None):
  '''Introduce local bindings.
  ex: LET(('a', 1,
           'b', 2),
          lambda o: [o.a, o.b])
  gives: [1, 2]

  Bindings down the chain can depend on
  the ones above them through a lambda.
  ex: LET(('a', 1,
           'b', lambda o: o.a + 1),
          lambda o: o.b)
  gives: 2
  '''
  if len(bindings) == 0:
    return body(env)

  env = env or _obj()
  k, v = bindings[:2]
  if isinstance(v, types.FunctionType):
    v = v(env)

  setattr(env, k, v)
  return LET(bindings[2:], body, env)

你现在可以像这样使用这个LET表单:

map(lambda x: LET(('y', x + 1,
                   'z', x - 1),
                  lambda o: o.y * o.z),
    [1, 2, 3])

结果是:[0,3,8]

让我试着解决@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。这有用吗?