Wie lokale variable in list comprehension?

Habe ich eine Methode, die eine Liste und ein Objekt zurück:

# input a list, returns an object
def map_to_obj(lst):
    a_list = f(lst)
    return a_list[0] if a_list else None

Ich möchte eine Liste, die alle zugeordneten Elemente, die nicht None.

Wie diese:

v_list = [v1, v2, v3, v4]

[map_to_obj(v) for v in v_list if map_to_obj(v)]

Aber es scheint nicht gut zu nennen die map_to_obj - Methode zweimal in der Liste erfassen.

Gibt es eine Möglichkeit, lokale Variablen in der Liste Verstehens, so dass Sie können haben eine bessere Leistung?

Oder weiß der compiler optimiert es automatisch?

Hier ist, was ich will:

(sml like)
[let mapped = map_to_obj(v) in for v in v_list if mapped end]

InformationsquelleAutor Hao Tan | 2014-10-31

list-comprehension python

50

Verschachtelte Liste Verständnis:

[x for x in [map_to_obj(v) for v in v_list] if x]

oder noch besser, eine Liste Verständnis um einen generator-Ausdruck:

[x for x in (map_to_obj(v) for v in v_list) if x]
- Es ist eine feine Antwort, und natürlich ist es das gleiche wie behzad's ein, mit Liste Verstehens statt map und filter... ich' werde upvote, wie ich mochte es, wie Liegenden Hund übersetzt filter in Bezug auf die l-c, aber die OP genehmigen dürfen, entweder eine von diesen Antworten, denn beide sind in Ordnung, nützlichen Antworten.
- Das innere Verständnis sollte ein generator-Ausdruck. Keine Notwendigkeit zu bauen, die gesamte Liste-und nur dann wegwerfen, die leere Elemente zu bauen, die noch eine weitere Liste.
- Imho Tim die Beratung ist fundiert und aussagekräftig, bitte Bearbeiten Sie Ihre Antwort zu reflektieren, seinen Vorschlag.
- Tim das ist ein guter Punkt, ich habe es.
- Ich von Ihnen positiv bewertet werden diese anstelle von behzad ist, weil die Liste Verstehens sind in der Regel schneller als die map/filter aufgrund der call-overhead lambda
- Wenn ein lambda (eigentlich die Python-Funktion implementiert, die das verstehen könnte-inline zu vermeiden, wird der Anruf overhead) beteiligt ist, ja, die listcomp gewinnt. map/filter gewinnen können, wenn die callback-Funktion ist eine C-built-in obwohl, wie Sie können, schieben Sie alle arbeiten auf der Schicht C, unter Umgehung der bytecode-interpreter-overhead, welcher listcomps nicht vermeiden können, wie Sie sind Python-level-Funktionen, nur mit direkter bytecode-Unterstützung für die append-to-list Schritt.
- Dummes Beispiel: Ändern behzad Antwort zu ersetzen lambda t: t is not None mit None.__ne__, während die immer-so-etwas verrückt ist, wie es funktioniert (es gibt False für andere Nones, und NotImplemented,, die passiert werden truthy, für alles andere), würde die Geschwindigkeit verbessern, dass die Lösung (in lokalen tests, die filter Arbeit sinkt um fast einen Faktor von 2), allerdings auf Kosten der Verständlichkeit.
InformationsquelleAutor Lying Dog
5

Einer Variablen Zuordnung ist nur eine einzelne Bindung:
```
[x   for v in l   for x in [v]]
```
Dies ist eine Allgemeine Antwort, und auch näher an dem, was Sie vorgeschlagen.
Also für Ihr problem, können Sie schreiben:
```
[x   for v in v_list   for x in [map_to_obj(v)]   if x]
```
- Dies unterscheidet sich von meiner Antwort nur mit einem 1-element-Liste anstelle von einem 1-element-Tupel, und ich denke, Tupel beats-Liste, wenn es nicht verändert werden. 🙂
InformationsquelleAutor Vincent Goossens
4

Können Sie vermeiden, re-Berechnung durch die Verwendung von python built-in - filter:
```
list(filter(lambda t: t is not None, map(map_to_obj, v_list)))
```
- Aber auch iteriert die Liste zweimal...
- Ist es ein one-iteration Lösung?
- nicht in python 3; in python 3, map gibt ein map Objekt ist keine Liste, und filter gibt ein filter-Objekt, so wird dies Kette die Funktionen, ohne dass intermediate-Listen.
- Ist es möglich mit reduce um die Arbeit zu tun?
- Warum würden Sie? reduce ist für die Kombination vieler Dinge nach unten, um eine Sache, nicht für die änderung viele Dinge zu viele Dinge. Die Arbeit erfolgt durch ein gekoppeltes map und filter (das ist dann listfreundlich) entspricht, erfolgt durch eine listcomp führt, dass beide Filter-und mapping-Operationen.
InformationsquelleAutor behzad.nouri
4

Ab Python 3.8, und die Einführung von bei der Zuordnung von Ausdrücken (PEP 572) (:= operator), es ist möglich, eine lokale variable innerhalb einer Liste Verständnis, um zu vermeiden, ruft zweimal die gleiche Funktion:

In unserem Fall, wir nennen können die Bewertung von map_to_obj(v) als variable o während über das Ergebnis des Ausdrucks " um die Liste zu filtern; und so verwenden o als der zugeordnete Wert:
```
[o for v in [v1, v2, v3, v4] if (o := map_to_obj(v))]
```
InformationsquelleAutor Xavier Guihot
2

Einer lokalen variable kann eingestellt werden, in ein Verständnis von ein wenig geschummelt und mit einem extra " für " die "iteriert" durch eine 1-element-Tupel mit den gewünschten Wert für die lokale variable. Hier ist eine Lösung für die OP, das problem mit diesem Ansatz:
```
[o for v in v_list for o in (map_to_obj(v),) if o]
```
Hier o ist die lokale variable festgelegt wird gleich map_to_obj(v) für jeden v.

In meinen tests, diese ist etwas schneller als Liegender Hund verschachtelten generator Ausdrücke (und auch schneller als die OP ' s double-call zu map_to_obj(v), was überraschend, kann schneller sein als das verschachtelte generator-Ausdruck, wenn die map_to_obj Funktion nicht zu langsam).

InformationsquelleAutor Ovaflo
1

Liste Verstehens sind in Ordnung für den einfachen Fällen, aber manchmal ist ein plain old for - Schleife ist die einfachste Lösung:
```
other_list = []
for v in v_list:
    obj = map_to_obj(v)
    if obj:
        other_list.append(obj)
```
Nun, wenn Sie wirklich wollen, eine Liste mit comp und nicht wollen, zu bauen eine tmp-Liste können Sie mit der iterator-Versionen filter und map:
```
import itertools as it
result = list(it.ifilter(None, it.imap(map_to_obj, v_list)))
```
oder mehr einfach :
```
import itertools as it
result = filter(None, it.imap(map_to_obj, v_list)))
```
Den iterator Versionen nicht bauen eine temporäre Liste, die Sie verwenden, lazy evaluation.

InformationsquelleAutor bruno desthuilliers
0

Habe ich herausgefunden, ein Weg, mit reduce:
```
def map_and_append(lst, v):
    mapped = map_to_obj(v)
    if mapped is not None:
        lst.append(mapped)
    return lst

reduce(map_and_append, v_list, [])
```
Wie über die Leistung dieser?
- Sie können die timeit Modul zu Zeit die verschiedenen Lösungen, aber deine obige snippet ist eine beliebig overcomplexificated Weg, um eine sehr einfache Sache - und ich bezweifle, dass es entweder schneller oder mehr Speicherplatz-effizienter als die gute alte for-Schleife oder die filter - /imap-Lösungen...
- Ich mag deine «overcomplexificated» !
- Wenn ich sehe, das keine itertools Antworten, die Leistung trotz, ich wage zu sagen, abliegenden Hund ist ein ist die ausdrucksstärkste der Absicht, und daher die meisten lesbar. Und was ist mit performance? naja, ich weiß nicht, wie viel cpu-verbringen Sie in Ihrem f(lst) Anrufe, aber das entfernen der Nones die eine oder andere Weise ist unwahrscheinlich, dass das gesamte Bild verändern.
- reduce wirklich nicht gefragt. Es ist für die Verringerung der Liste der Werte zu einem einzigen Wert (in der Regel eine Liste von skalaren zu einem einzigen Skalar), nicht die Umwandlung einer Liste in eine andere Liste.
InformationsquelleAutor Hao Tan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.