Eliminazione di chiamate di funzioni ridondanti in comprensione dall'interno della comprensione

Question

Supponiamo di aver bisogno di un programma che prende un elenco di stringhe e le divide e aggiunge le prime due parole, in una tupla, a un elenco e restituisce tale elenco; in altre parole, un programma che ti dà le prime due parole di ogni stringa.

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

Può essere scritto in questo modo (si suppone di ingresso valido):

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

Ma una lista di comprensione sarebbe molto più bello.

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

Ma questo comporta due chiamate a split(). C'è un modo per eseguire la divisione solo una volta all'interno della comprensione? Ho provato quello che è venuto naturale ed è stato sintassi non valida:

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

Ebbene, in questo caso particolare:

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

In caso contrario, però, è possibile utilizzare uno generatore di espressione :

E se le prestazioni sono davvero critiche, basta usare una funzione.

Answer 2

Ti piace?

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

Utilizza lo splicing di elenchi. Si restituirà un elenco, naturalmente, ma se volete una tupla, è possibile utilizzare:

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

Answer 3

Scrivere ciò che viene in mente naturalmente dall'inglese e sperare che la sua sintassi valida funzioni raramente, sfortunatamente.

La forma generalizzata di ciò che si sta tentando di fare è legare un'espressione a un nome all'interno di una comprensione. Non c'è alcun supporto diretto a questo, ma dal momento che una clausola for in una comprensione si lega un nome a ciascun elemento da una sequenza, a sua volta, è possibile utilizzare for over contenitori a singolo elemento per ottenere lo stesso effetto:

>>> 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 pensare di usare un genexp è più bello, ma ecco come farlo con un lambda. Ci possono essere casi in cui questo è un adattamento migliore

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

Answer 5

La risposta di minitech è il modo giusto per farlo.

Ma si noti che non è necessario eseguire tutto in una riga e non si guadagna nulla.

questo:

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

fa esattamente la stessa cosa come questa:

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

Nessun valori intermedi in più in fase di costruzione, nessun effetto sulla raccolta dei rifiuti, solo più leggibilità gratuitamente.

Inoltre, c'è una buona probabilità che il codice vero e proprio in realtà non ha bisogno di una lista, alla fine, solo qualcosa iterabile, nel qual caso si sta meglio con questo:

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

Oppure, in Python 3.3+:

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

---

In realtà, un sacco di programmi può essere scritto in questo modo, una serie di espressioni generatore seguito da return ing/yield from ing un'ultima genex pr/listcomp.

Answer 6

itemgetter può essere utilizzato qui. È un po 'più generale di s.split()[:2]. Esso consente di estrarre gli elementi arbitrari di 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')] 

più in generale:

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