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

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]

以下是几个相关的连结:

有一段时间，我一直在跟踪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函数应该是单行的，作为函数的最简单形式，一个入口，然后返回

在lambda项之间传递任意数量变量的一个安全方法:

print((lambda: [
    locals().__setitem__("a", 1),
    locals().__setitem__("b", 2),
    locals().__setitem__("c", 3),
    locals().get("a") + locals().get("b") + locals().get("c")
])()[-1])

输出:6

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

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

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

(对于仍然对这个话题感兴趣的人。)

考虑一下这一点(甚至包括在“multiline”lambda中的进一步语句中使用语句的返回值，尽管它丑陋到令人作呕;-)

>>> def foo(arg):
...     result = arg * 2;
...     print "foo(" + str(arg) + ") called: " + str(result);
...     return result;
...
>>> f = lambda a, b, state=[]: [
...     state.append(foo(a)),
...     state.append(foo(b)),
...     state.append(foo(state[0] + state[1])),
...     state[-1]
... ][-1];
>>> f(1, 2);
foo(1) called: 2
foo(2) called: 4
foo(6) called: 12
12