在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

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

考虑一下这一点(甚至包括在“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

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

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

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

关于丑陋的黑客，你总是可以使用exec和常规函数的组合来定义一个多行函数，就像这样:

f = exec('''
def mlambda(x, y):
    d = y - x
    return d * d
''', globals()) or mlambda

你可以把它包装成这样一个函数:

def mlambda(signature, *lines):
    exec_vars = {}
    exec('def mlambda' + signature + ':\n' + '\n'.join('\t' + line for line in lines), exec_vars)
    return exec_vars['mlambda']

f = mlambda('(x, y)',
            'd = y - x',
            'return d * d')

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

例子:

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

Output: 30

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

一个简单的单行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表现得像函数!

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