Wie funktioniert dieses Lambda / Ertrag / Generator-Verständnis?

Ich war auf der Suche durch meine codebase heute und fand diese:

def optionsToArgs(options, separator='='):
    kvs = [
        (
            "%(option)s%(separator)s%(value)s" %  
            {'option' : str(k), 'separator' : separator, 'value' : str(v)}
        ) for k, v in options.items()
    ]
    return list(
        reversed(
            list(
                    (lambda l, t: 
                        (lambda f: 
                            (f((yield x)) for x in l)
                        )(lambda _: t)
                    )(kvs, '-o')
                )
            )
        )

Es scheint eine dict-Parameter, und schalten Sie Sie in eine Liste von Parametern für ein shell-Befehl. Wie es aussieht ist es mit der Ausbeute im inneren eine generator-comprehension, ich dachte, das wäre unmöglich...?

>>> optionsToArgs({"x":1,"y":2,"z":3})
['-o', 'z=3', '-o', 'x=1', '-o', 'y=2']

Wie funktioniert es?

Kommentar zu dem Problem
Dang. Sprechen Sie über die nicht lesbare code. Kommentarautor: BenDundee
der lustigste Teil ist der - Liste(reversed(list( - Teil zu Holen Sie sich die -o Schalter rechts, obwohl Kommentarautor: ch3ka
Auch alle lambdas haben könnte, wurden nur ((lambda _: '-o')((Ertrag x)) für x kvs) Kommentarautor: Pavel Anossov
... und auch die return-Anweisung konnte nur werden, ausgedrückt als [v, für o-kvs-v in ["-o", o]]. Kommentarautor: l4mpi
Das erinnert mich an duffs device. Von diesem Tag an wird für immer bekannt sein als Hunde Gerät, lol. Kommentarautor: Eric des Courtis

InformationsquelleAutor der Frage Dog | 2013-04-11

  1. 47

    Seit Python 2.5, yield <value> ist ein Ausdruck, keine Anweisung. Sehen PEP 342.

    Der code ist furchtbar und unnötig hässlich, aber es ist legal. Seine zentrale trick besteht darin, mit f((yield x)) im inneren des Generators-Ausdruck. Hier ein einfacheres Beispiel, wie das funktioniert:

    >>> def f(val):
...     return "Hi"
>>> x = [1, 2, 3]
>>> list(f((yield a)) for a in x)
[1, 'Hi', 2, 'Hi', 3, 'Hi']

    Grundsätzlich mit yield im generator-Ausdruck bewirkt, dass es erzeugen zwei Werte für jeden Wert in der Quelle durchsuchbar. Als der generator-Ausdruck iteriert über die Liste der Zeichenfolgen, die bei jeder iteration, die yield x erste liefert einen string aus der Liste. Die target-expression der genexp ist f((yield x)), so wird für jeden Wert in der Liste, das "Ergebnis" des generator-Ausdrucks ist der Wert von f((yield x)). Aber f einfach ignoriert argument und gibt immer die option string "-o". So auf jedem Schritt durch den generator liefert es erste Schlüssel-Wert-string (z.B. "x=1"), dann "-o". Die äußeren list(reversed(list(...))) macht einfach eine Liste von diesen generator und dann kehrt es um, so dass die "-o"s kommen vor jeder option nicht nach.

    Jedoch, es gibt keinen Grund, es zu tun auf diese Weise. Es gibt eine Reihe von viel mehr lesbare alternativen. Vielleicht expliziteste ist einfach:

    kvs = [...] # same list comprehension can be used for this part
result = []
for keyval in kvs:
   result.append("-o")
   result.append(keyval)
return result

    Selbst wenn man, wie knapp, "clever" - code, Sie konnten gerade noch tun

    return sum([["-o", keyval] for keyval in kvs], [])

    Den kvs Liste das Verständnis selbst ist eine bizarre Mischung aus versucht, die Lesbarkeit und unlesbarkeit. Es ist einfach geschrieben:

    kvs = [str(optName) + separator + str(optValue) for optName, optValue in options.items()]

    Sollten Sie erwägen, die Anordnung einer "intervention", denn wer diese in Ihrer Codebasis.

    InformationsquelleAutor der Antwort BrenBarn

  2. 19

    Oh Gott. Im Grunde läuft es auf diese:

    def f(_):              # I'm the lambda _: t
    return '-o'

def thegenerator():   # I'm (f((yield x)) for x in l)
    for x in kvs:
        yield f((yield x))

    Also bei der Iteration thegenerator Erträge x (Mitglied kvs) und dann die return-Wert f, das ist immer -o alle in einer iteration über kvs. Was yield x gibt und was wird übergeben f ignoriert.

    Entsprechungen:

    def thegenerator():   # I'm (f((yield x)) for x in l)
    for x in kvs:
        whatever = (yield x)
        yield f(whatever)

def thegenerator():   # I'm (f((yield x)) for x in l)
    for x in kvs:
        yield x
        yield f(None)

def thegenerator():   # I'm (f((yield x)) for x in l)
    for x in kvs:
        yield x
        yield '-o'

    Gibt es viele Möglichkeiten, dies zu tun viel einfacher, natürlich. Sogar mit der original double-yield-trick, die ganze Sache könnte habe 

    return list(((lambda _: '-o')((yield x)) for x in kvs))[::-1]

    InformationsquelleAutor der Antwort Pavel Anossov

Schreibe einen Kommentar