Pas de Lambda multiligne en Python: pourquoi pas?

J'ai entendu dire que les lambdas multilignes ne peuvent pas être ajoutés en Python car ils se heurteraient syntaxiquement aux autres constructions de syntaxe en Python. J'y pensais aujourd'hui dans le bus et j'ai réalisé que je ne pouvais pas penser à une seule construction Python avec laquelle les lambdas multilignes se heurtent. Étant donné que je connais assez bien la langue, cela m'a surpris.

Maintenant, je suis sûr que Guido avait une raison de ne pas inclure les lambdas multilignes dans la langue, mais par curiosité: dans quelle situation l'inclusion d'une lambda multilignes serait-elle ambiguë? Ce que j'ai entendu est-il vrai, ou y a-t-il une autre raison pour laquelle Python n'autorise pas les lambdas multilignes?

Regardez ce qui suit:

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

Est-ce un lambda qui revient (y, [1,2,3])(donc la carte n'obtient qu'un seul paramètre, ce qui entraîne une erreur)? Ou revient-il y? Ou s'agit-il d'une erreur de syntaxe, car la virgule sur la nouvelle ligne est mal placée? Comment Python saurait-il ce que vous voulez?

Dans les parens, l'indentation n'a pas d'importance pour Python, vous ne pouvez donc pas travailler sans ambiguïté avec les multilignes.

Ceci est juste un simple, il y a probablement plus d'exemples.

Guido van Rossum (l'inventeur de Python) répond lui-même à cette question exacte dans un ancien article de blog .
Fondamentalement, il admet que c'est théoriquement possible, mais que toute solution proposée serait non-Pythonique:

"Mais la complexité de toute solution proposée pour ce casse-tête est immense, pour moi: elle nécessite que l'analyseur (ou plus précisément, le lexer) puisse basculer entre les modes sensibles au retrait et insensibles au retrait, en gardant une pile des modes précédents et du niveau d'indentation. Techniquement, tout cela peut être résolu (il y a déjà une pile de niveaux d'indentation qui pourraient être généralisés). Mais rien de tout cela n'enlève à mon instinct le sentiment que tout cela est un engin élaboré de Rube Goldberg . "

C'est généralement très laid (mais parfois les alternatives sont encore plus laides), donc une solution de contournement consiste à faire une expression d'accolades:

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

Cependant, il n'acceptera aucune affectation, vous devrez donc préparer les données à l'avance. L'endroit que j'ai trouvé utile est le wrapper PySide, où vous avez parfois de courts rappels. Écrire des fonctions membres supplémentaires serait encore plus moche. Normalement, vous n'en aurez pas besoin.

Exemple:

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

Quelques liens pertinents:

Pendant un certain temps, je suivais le développement de Reia, qui allait initialement avoir la syntaxe basée sur l'indentation de Python avec des blocs Ruby, le tout au-dessus d'Erlang. Mais, le concepteur a fini par abandonner la sensibilité à l'indentation, et ce post qu'il a écrit sur cette décision comprend une discussion sur les problèmes qu'il a rencontrés avec l'indentation + les blocs multi-lignes, et une appréciation accrue qu'il a acquise pour les problèmes / décisions de conception de Guido:

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

En outre, voici une proposition intéressante pour les blocs de style Ruby en Python que j'ai rencontré où Guido publie une réponse sans réellement l'abattre (cependant, je ne suis pas sûr qu'il y ait eu un abattage ultérieur):

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

[Modifier] Lisez cette réponse. Cela explique pourquoi le lambda multiligne n'est pas une chose.

Autrement dit, c'est impythonique. Extrait du blog de Guido van Rossum:

Je trouve inacceptable toute solution qui incorpore un bloc basé sur l'indentation au milieu d'une expression. Étant donné que je trouve une syntaxe alternative pour le regroupement d'instructions (par exemple, accolades ou mots-clés de début / fin) tout aussi inacceptable, cela rend à peu près un lambda multi-lignes un puzzle insoluble.

Permettez-moi de vous présenter un hack glorieux mais terrifiant:

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)

Vous pouvez maintenant utiliser ce LETformulaire comme tel:

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

qui donne: [0, 3, 8]

Je suis coupable de pratiquer ce sale hack dans certains de mes projets, ce qui est un peu plus simple:

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

J'espère que vous pouvez trouver un moyen de rester pythonique, mais si vous devez le faire, cela est moins douloureux que d'utiliser exec et de manipuler les globaux.

Permettez-moi d'essayer de résoudre le problème d'analyse @balpha. J'utiliserais des parenthèses autour de la lamda multiligne. S'il n'y a pas de parenthèses, la définition lambda est gourmande. Donc, le lambda dans

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

renvoie une fonction qui renvoie (y*z, [1,2,3])

Mais

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

veux dire

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

où func est le lambda multiligne qui renvoie y * z. Est-ce que ça marche?

(Pour toute personne encore intéressée par le sujet.)

Considérez ceci (inclut même l'utilisation des valeurs de retour des instructions dans d'autres instructions au sein du lambda "multiligne", bien que ce soit moche au point de vomir ;-)

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

Vous pouvez simplement utiliser slash ( \) si vous avez plusieurs lignes pour votre fonction lambda

Exemple:

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

Output: 30

Je commence par python mais venant de Javascript le moyen le plus évident est d'extraire l'expression en fonction ....

Exemple artificiel, l'expression multiplie (x*2)est extraite en fonction et je peux donc utiliser multiligne:

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

Peut-être que cela ne répond pas exactement à la question si c'était comment faire la multiligne dans l'expression lambda elle - même , mais au cas où quelqu'un obtiendrait ce fil en cherchant comment déboguer l'expression (comme moi), je pense que cela aidera

Au sujet des hacks laids, vous pouvez toujours utiliser une combinaison de execet une fonction régulière pour définir une fonction multiligne comme ceci:

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

Vous pouvez envelopper cela dans une fonction comme:

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

Je jouais juste un peu pour essayer de faire une compréhension de dict avec réduire, et arriver à ce hack d'une ligne:

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}

J'essayais juste de faire la même chose que ce qui a été fait dans cette compréhension de dict Javascript: https://stackoverflow.com/a/11068265

Voici une implémentation plus intéressante des lambdas multi-lignes. Ce n'est pas possible à réaliser à cause de la façon dont python utilise les retraits comme moyen de structurer le code.

Mais heureusement pour nous, le formatage en retrait peut être désactivé à l'aide de tableaux et de parenthèses.

Comme certains l'ont déjà souligné, vous pouvez écrire votre code comme tel:

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

En théorie, si vous êtes assuré d'avoir une évaluation de gauche à droite, cela fonctionnerait, mais vous perdez toujours des valeurs transmises d'une expression à une autre.

Une façon de réaliser ce qui est un peu plus verbeux est d’avoir

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

Où chaque lambda reçoit des arguments de la précédente.

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

Cette méthode vous permet d'écrire quelque chose qui ressemble un peu à un lisp / schéma.

Vous pouvez donc écrire des choses comme ceci:

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

Une méthode plus complexe pourrait être utilisée pour calculer l'hypoténuse

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

Cela renverra une liste de nombres scalaires afin qu'il puisse être utilisé pour réduire plusieurs valeurs à un.

Avoir autant de lambda ne sera certainement pas très efficace, mais si vous êtes contraint, cela peut être un bon moyen de faire quelque chose rapidement, puis de le réécrire en tant que fonction réelle plus tard.

parce qu'une fonction lambda est censée être unilatérale, car c'est la forme la plus simple d'une fonction, an entrance, then return