Vermeiden redundante Funktionsaufrufe in Comprehensions aus dem Verständnis

Question

Sagen wir brauchen ein Programm, das eine Liste von Zeichenfolgen und spaltet sie, und hängt die ersten beiden Wörter, in einem Tupel, an eine Liste und gibt diese Liste zurück; Mit anderen Worten, ein Programm, das Ihnen die ersten zwei Wörter jeder Zeichenfolge gibt.

input: ["hello world how are you", "foo bar baz"] 
output: [("hello", "world"), ("foo", "bar")] 

Es kann wie so geschrieben werden (wir gültige Eingabe übernehmen):

def firstTwoWords(strings): 
    result = [] 
    for s in strings: 
     splt = s.split() 
     result.append((splt[0], splt[1])) 
    return result 

Aber eine Liste Verständnis wäre viel schöner.

def firstTwoWords(strings): 
    return [(s.split()[0], s.split()[1]) for s in strings] 

Aber dies beinhaltet zwei Aufrufe an split(). Gibt es eine Möglichkeit, die Aufteilung nur einmal innerhalb des Verständnisses durchzuführen? Ich habe versucht, was kam, natürlich, und es war eine ungültige Syntax:

>>> [(splt[0],splt[1]) for s in strings with s.split() as splt] 
    File "<stdin>", line 1 
    [(splt[0],splt[1]) for s in strings with s.split() as splt] 
             ^
SyntaxError: invalid syntax 

Answer 1

Nun, in diesem speziellen Fall:

def firstTwoWords(strings): 
    return [s.split()[:2] for s in strings] 

Ansonsten aber können Sie einen Generator Ausdruck verwenden :

def firstTwoWords(strings): 
    return [(s[0], s[1]) for s in (s.split() for s in strings)] 

Und wenn Leistung tatsächlich kritisch ist, verwenden Sie einfach eine Funktion.

Answer 2

Wie das?

def firstTwoWords(strings): 
    return [s.split()[:2] for s in strings] 

Es verwendet List-Splicing. Es wird eine Liste natürlich zurück, aber wenn Sie ein Tupel möchten, können Sie verwenden:

def firstTwoWords(strings): 
    return [tuple(s.split()[:2]) for s in strings] 

Answer 3

Schreiben, was natürlich aus dem Englischen in den Sinn kommt und hofft, dass seine gültige Syntax selten funktioniert, leider.

Die verallgemeinerte Form von dem, was Sie versuchen, ist, einen Ausdruck an einen Namen innerhalb eines Verständnisses zu binden. Es gibt keine direkte Unterstützung für das, aber da eine for Klausel in einem Verständnis einen Namen aus einer Folge wiederum zu jedem Elemente bindet, Sie for über Einzelelement-Behälter verwenden, können den gleichen Effekt zu erzielen:

>>> strings = ["hello world how are you", "foo bar baz"] 
>>> [(splt[0],splt[1]) for s in strings for splt in [s.split()]] 
[('hello', 'world'), ('foo', 'bar')] 

Answer 4

I denke mit einem Genexp ist schöner, aber hier ist, wie es mit einem lambda zu tun. Es kann Fälle geben, wenn dies ist eine bessere Passform

>>> [(lambda splt:(splt[0], splt[1]))(s.split()) for s in input] 
[('hello', 'world'), ('foo', 'bar')] 

Answer 5

MiniTech Antwort ist der richtige Weg, es zu tun.

Aber beachten Sie, dass Sie nicht alles in einer Zeile tun müssen, und Sie wirklich nichts gewinnen.

Dies:

splits = (s.split() for s in strings) 
return [(s[0], s[1]) for s in splits] 

tut genau das Gleiche wie folgt aus:

return [(s[0], s[1]) for s in (s.split() for s in strings)] 

Keine zusätzlichen Zwischenwerte gebaut, keine Auswirkungen auf die Garbage Collection, nur mehr Lesbarkeit kostenlos.

Auch gibt es eine gute Chance, Ihren echten Code tatsächlich keine Liste am Ende braucht, nur etwas iterable, in welchem ​​Fall du bist besser dran mit diesem:

splits = (s.split() for s in strings) 
return ((s[0], s[1]) for s in splits) 

Oder in Python 3.3+:

splits = (s.split() for s in strings) 
yield from ((s[0], s[1]) for s in splits) 

---

In der Tat kann eine ganze Menge von Programmen geschrieben werden auf diese Weise-eine Reihe von Generator Ausdrücke, gefolgt von return ing/yield from ing ein letztes Genex pr/Listenkomp.

Answer 6

itemgetter kann hier verwendet werden. Es ist ein bisschen allgemeiner als s.split()[:2]. Es ermöglicht Ihnen, beliebige Artikel aus s

>>> from operator import itemgetter 
>>> strings = ["hello world how are you", "foo bar baz"] 
>>> [itemgetter(0, 1)(s.split()) for s in strings] 
[('hello', 'world'), ('foo', 'bar')] 

allgemeiner ziehen:

>>> [itemgetter(1, 2, 0)(s.split()) for s in strings] 
[('world', 'how', 'hello'), ('bar', 'baz', 'foo')]