Optimiser une compréhension de la liste

Question

Voici un extrait de code qui montre le code que je voudrais optimiser:

result = [(item, foo(item)) 
      for item in item_list 
      if cond1(item) and cond2(foo(item))] 

Dans l'extrait ci-dessus que j'appelle foo(item) deux fois. Je ne peux pas penser à un moyen d'itérer sur la liste seulement une fois maintenir à la fois item et foo(item) pour le conditionnel et la liste de résultats.

C'est, je voudrais garder item et foo(item) sans avoir à faire deux fois la boucle sur la liste et sans avoir à appeler foo(item).

Je sais que je peux le faire avec une deuxième compréhension de la liste imbriquée:

result = [(item, foo_item) 
      for item, foo_item in [(i, foo(i)) for i in item_list] 
      if cond1(item) and cond2(foo_item)] 

mais qui semble boucle à travers item_list deux fois que je voudrais éviter.

Ainsi, le premier exemple appelle foo deux fois par élément de liste. Le deuxième exemple parcourt deux fois la liste (ou apparaît). Je voudrais boucler une fois et appeler le foo une fois pour chaque article.

Answer 1

Il n'a pas, mais ici:

result = [(item, foo_item) 
    for item, foo_item in ((i, foo(i)) for i in item_list) 
    if cond1(item) and cond2(foo_item)] 

Tourner la compréhension de la liste intérieure dans une expression génératrice fait en sorte que nous ne l'utilisons pas une liste temporaire inutile.

Answer 2

Comme je l'ai été dit à plusieurs reprises ici, la meilleure chose dans ce cas est de ne pas utiliser une compréhension de la liste à tous:

result = [] 
for item in item_list: 
    if cond1(item): 
     value = foo(item) 
     if cond2(value): 
      result.append((item, value)) 

Mais je suis stubbborn, donc nous allons voir ce que je peux venir avec (et gardez la compréhension) (oh, attendez - j'ai tout votre code erroné.Détaillant - et déplaçant des variables intermédiaires est la manière directe de ne pas répéter l'appel)

Answer 3

Comment cela ressemble-t-il?

result = [ (i, fi) for i in item_list if cond1(i) 
        for fi in (foo(i),) if cond2(fi) ] 

Answer 4

Utiliser des expressions de générateur.

result = [(item, foo_item) 
      for item, foo_item in ((i, foo(i)) for i in item_list) 
      if cond1(item) and cond2(foo_item)] 

L'interprète passera par chaque élément exactement une fois, parce que l'expression du générateur calcule (i, foo(i)) seulement quand il est requis par la boucle extérieure.

En supposant que foo est cher et n'a pas d'effets secondaires, je dirais même essayer de le faire:

result = [(item, foo_item) 
      for item, foo_item in ((i, foo(i)) for i in item_list if cond1(i)) 
      if cond2(foo_item)] 

de sorte que foo ne seront pas appelés pour les éléments qui ne passent pas la première condition. En fait, cela semble mieux pour moi quand il est écrit fonctionnellement:

from itertools import imap, ifilter 
result = filter((lambda i,f:cond2(f)), 
      imap((lambda i:(i, foo(i))), 
      ifilter(cond1, item_list))) 

... mais je pourrais être subjective.

Answer 5

Ceci est l'une des nombreuses raisons pour lesquelles nous avons des générateurs:

def generator(items): 
    for item in items: 
     if cond1(item): 
      food = foo(item) 
      if food: 
       yield item, food 

result = list(generator(item_list)) 

LCs ne sont bons quand ils regardent bien - si vous devez les étaler sur 3 lignes juste pour les rendre lisibles, il est une mauvaise idée .