Não há Lambda multilinha no Python: por que não?

Ouvi dizer que lambdas multilinhas não podem ser adicionadas no Python porque elas colidiriam sintaticamente com outras construções de sintaxe no Python. Eu estava pensando sobre isso no ônibus hoje e percebi que não conseguia pensar em uma única construção Python com a qual as lambdas multilinhas se chocassem. Dado que conheço bem o idioma, isso me surpreendeu.

Agora, tenho certeza de que Guido tinha um motivo para não incluir lambdas multilinhas no idioma, mas por curiosidade: qual é a situação em que incluir uma lambda multilinha seria ambíguo? É o que eu ouvi falar verdade, ou há algum outro motivo pelo qual o Python não permite lambdas multilinhas?

Veja o seguinte:

map(multilambda x:
      y=x+1
      return y
   , [1,2,3])

É um retorno lambda (y, [1,2,3])(assim, o mapa obtém apenas um parâmetro, resultando em um erro)? Ou volta y? Ou é um erro de sintaxe, porque a vírgula na nova linha está incorreta? Como Python saberia o que você quer?

Dentro da parênteses, a indentação não importa para python, então você não pode trabalhar sem ambiguidade com multilinhas.

Este é apenas um exemplo simples, provavelmente há mais exemplos.

Guido van Rossum (o inventor do Python) responde a essa pergunta exata em um antigo post de blog .
Basicamente, ele admite que é teoricamente possível, mas que qualquer solução proposta seria não-pitonica:

"Mas a complexidade de qualquer solução proposta para esse quebra-cabeça é imensa para mim: exige que o analisador (ou mais precisamente, o lexer) seja capaz de alternar entre os modos sensível ao recuo e insensível ao recuo, mantendo uma pilha dos modos anteriores e do nível de indentação. Tecnicamente, tudo isso pode ser resolvido (já existe uma pilha de níveis de indentação que pode ser generalizada). Mas nada disso tira o meu pressentimento de que tudo é uma engenhoca elaborada de Rube Goldberg ".

Isso geralmente é muito feio (mas às vezes as alternativas são ainda mais feias), portanto, uma solução alternativa é fazer uma expressão entre chaves:

lambda: (
    doFoo('abc'),
    doBar(123),
    doBaz())

Porém, ele não aceita nenhuma atribuição, portanto, você deverá preparar os dados com antecedência. O local que achei útil é o wrapper PySide, onde às vezes você tem retornos curtos. Escrever funções-membro adicionais seria ainda mais feio. Normalmente você não precisará disso.

Exemplo:

pushButtonShowDialog.clicked.connect(
    lambda: (
    field1.clear(),
    spinBox1.setValue(0),
    diag.show())

Alguns links relevantes:

Por um tempo, eu estava acompanhando o desenvolvimento do Reia, que inicialmente teria a sintaxe baseada em indentação do Python com blocos Ruby também, tudo sobre Erlang. Mas, o designer acabou desistindo da sensibilidade do recuo, e este post que ele escreveu sobre essa decisão inclui uma discussão sobre problemas com os quais ele se deparou com recuo + blocos de várias linhas e uma apreciação maior que ele ganhou pelas questões / decisões de design de Guido:

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

Além disso, aqui está uma proposta interessante para os blocos de estilo Ruby no Python que encontrei em Guido, onde uma resposta foi lançada sem realmente derrubá-la (não tenho certeza se houve alguma derrubada subsequente):

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

[Editar] Leia esta resposta. Explica por que lambda multilinha não é uma coisa.

Simplificando, é atípico. Da publicação de blog de Guido van Rossum:

Acho inaceitável qualquer solução que incorpore um bloco baseado em recuo no meio de uma expressão. Como acho a sintaxe alternativa para o agrupamento de instruções (por exemplo, chaves ou palavras-chave de início / fim) igualmente inaceitável, isso praticamente torna um lambda de várias linhas um quebra-cabeça insolúvel.

Deixe-me apresentar um corte glorioso, mas aterrador:

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)

Agora você pode usar este LETformulário da seguinte forma:

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

que dá: [0, 3, 8]

Sou culpado de praticar esse truque sujo em alguns dos meus projetos, que é um pouco mais simples:

    lambda args...:( expr1, expr2, expr3, ...,
            exprN, returnExpr)[-1]

Espero que você consiga encontrar uma maneira de se manter pythonic, mas se você tiver que fazer isso menos doloroso do que usar exec e manipular globals.

Deixe-me tentar resolver o problema de análise do @balpha. Eu usaria parênteses ao redor da lamda multilinha. Se não houver parênteses, a definição lambda é gananciosa. Então a lambda em

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

retorna uma função que retorna (y*z, [1,2,3])

Mas

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

significa

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

onde func é a lambda multilinha que retorna y * z. Isso funciona?

(Para quem ainda estiver interessado no tópico.)

Considere isso (inclui o uso uniforme dos valores de retorno das declarações em outras declarações dentro da lambda "multilinha", embora seja feio a ponto de vomitar ;-)

>>> 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

Você pode simplesmente usar slash ( \) se tiver várias linhas para sua função lambda

Exemplo:

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

Output: 30

Estou começando com python, mas vindo do Javascript, a maneira mais óbvia é extrair a expressão como uma função ....

Exemplo artificial, a expressão multiplicar (x*2)é extraída como função e, portanto, eu posso usar várias linhas:

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

Talvez não responda exatamente à pergunta se foi assim que fazer multilinha na própria expressão lambda , mas caso alguém obtenha esse encadeamento procurando depurar a expressão (como eu), acho que ajudará

No assunto de hacks feios, você sempre pode usar uma combinação de exece uma função regular para definir uma função de múltiplas linhas como esta:

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

Você pode agrupar isso em uma função como:

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')

Eu estava apenas brincando um pouco para tentar entender o ditado com o reduzir e criar esse truque de liner:

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}

Eu estava apenas tentando fazer o mesmo que foi feito nesta compreensão de dict Javascript: https://stackoverflow.com/a/11068265

Aqui está uma implementação mais interessante de lambdas de várias linhas. Não é possível obter isso devido ao modo como o python usa recuos como uma maneira de estruturar o código.

Felizmente, para nós, a formatação de recuo pode ser desativada usando matrizes e parênteses.

Como alguns já apontaram, você pode escrever seu código assim:

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

Em teoria, se você tiver uma avaliação da esquerda para a direita, isso funcionaria, mas você ainda perde valores sendo transmitidos de uma expressão para outra.

Uma maneira de conseguir o que é um pouco mais detalhado é ter

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

Onde cada lambda recebe argumentos do anterior.

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

Este método permite que você escreva algo que seja um pouco lisp / esquema.

Então você pode escrever coisas assim:

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

Um método mais complexo pode ser usado para calcular a hipotenusa

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

Isso retornará uma lista de números escalares para que possa ser usado para reduzir vários valores para um.

Ter tantos lambda certamente não será muito eficiente, mas se você estiver com restrições, pode ser uma boa maneira de fazer algo rapidamente, depois reescreva-o como uma função real posteriormente.

porque uma função lambda deve ter uma linha, pois é a forma mais simples de uma função, an entrance, then return