Expressions de générateur contre compréhension de liste

Quand devez-vous utiliser des expressions de générateur et quand devez-vous utiliser des compréhensions de liste en Python?

# Generator expression
(x*2 for x in range(256))

# List comprehension
[x*2 for x in range(256)]

La réponse de John est bonne (les listes sont mieux comprises lorsque vous souhaitez répéter plusieurs fois quelque chose). Cependant, il convient également de noter que vous devez utiliser une liste si vous souhaitez utiliser l'une des méthodes de liste. Par exemple, le code suivant ne fonctionnera pas:

def gen():
    return (something for something in get_some_stuff())

print gen()[:2]     # generators don't support indexing or slicing
print [5,6] + gen() # generators can't be added to lists

Fondamentalement, utilisez une expression de générateur si tout ce que vous faites est d'itérer une fois. Si vous souhaitez stocker et utiliser les résultats générés, alors vous êtes probablement mieux avec une liste de compréhension.

Étant donné que la performance est la raison la plus courante de choisir l'un plutôt que l'autre, mon conseil est de ne pas s'en inquiéter et d'en choisir un; si vous trouvez que votre programme s'exécute trop lentement, alors et seulement à ce moment-là, devriez-vous revenir en arrière et vous soucier de régler votre code.

Itérer sur l' expression du générateur ou la compréhension de la liste fera la même chose. Cependant, la compréhension de la liste créera d'abord la liste entière en mémoire tandis que l' expression du générateur créera les éléments à la volée, vous pouvez donc l'utiliser pour des séquences très grandes (et aussi infinies!).

Utilisez des compréhensions de liste lorsque le résultat doit être répété plusieurs fois ou lorsque la vitesse est primordiale. Utilisez des expressions de générateur où la plage est grande ou infinie.

Voir Expressions de générateur et compréhensions de liste pour plus d'informations.

L'important est que la compréhension de la liste crée une nouvelle liste. Le générateur crée un objet itérable qui "filtre" le matériel source à la volée lorsque vous consommez les bits.

Imaginez que vous ayez un fichier journal de 2 To appelé "énormefichier.txt" et que vous souhaitiez le contenu et la longueur de toutes les lignes commençant par le mot "ENTRY".

Vous essayez donc de commencer par écrire une liste de compréhension:

logfile = open("hugefile.txt","r")
entry_lines = [(line,len(line)) for line in logfile if line.startswith("ENTRY")]

Cela accélère le fichier entier, traite chaque ligne et stocke les lignes correspondantes dans votre tableau. Ce tableau peut donc contenir jusqu'à 2 To de contenu. C'est beaucoup de RAM, et ce n'est probablement pas pratique pour vos besoins.

Nous pouvons donc utiliser un générateur pour appliquer un "filtre" à notre contenu. Aucune donnée n'est réellement lue jusqu'à ce que nous commencions à répéter le résultat.

logfile = open("hugefile.txt","r")
entry_lines = ((line,len(line)) for line in logfile if line.startswith("ENTRY"))

Pas même une seule ligne n'a encore été lue dans notre fichier. En fait, disons que nous voulons filtrer notre résultat encore plus loin:

long_entries = ((line,length) for (line,length) in entry_lines if length > 80)

Rien n'a encore été lu, mais nous avons spécifié maintenant deux générateurs qui agiront sur nos données comme nous le souhaitons.

Permet d'écrire nos lignes filtrées dans un autre fichier:

outfile = open("filtered.txt","a")
for entry,length in long_entries:
    outfile.write(entry)

Maintenant, nous lisons le fichier d'entrée. Comme notre forboucle continue de demander des lignes supplémentaires, le long_entriesgénérateur demande des lignes au entry_linesgénérateur, renvoyant uniquement celles dont la longueur est supérieure à 80 caractères. Et à son tour, le entry_linesgénérateur demande des lignes (filtrées comme indiqué) à l' logfileitérateur, qui à son tour lit le fichier.

Ainsi, au lieu de "pousser" les données vers votre fonction de sortie sous la forme d'une liste entièrement remplie, vous donnez à la fonction de sortie un moyen de "tirer" les données uniquement lorsque cela est nécessaire. C'est dans notre cas beaucoup plus efficace, mais pas aussi flexible. Les générateurs sont à sens unique, un passage; les données du fichier journal que nous avons lu sont immédiatement supprimées, nous ne pouvons donc pas revenir à une ligne précédente. D'un autre côté, nous n'avons pas à nous soucier de conserver les données une fois que nous en avons terminé.

L'avantage d'une expression de générateur est qu'elle utilise moins de mémoire car elle ne construit pas la liste entière à la fois. Les expressions de générateur sont mieux utilisées lorsque la liste est un intermédiaire, comme la somme des résultats ou la création d'un dict à partir des résultats.

Par exemple:

sum(x*2 for x in xrange(256))

dict( (k, some_func(k)) for k in some_list_of_keys )

L'avantage est que la liste n'est pas complètement générée, et donc peu de mémoire est utilisée (et devrait également être plus rapide)

Vous devez cependant utiliser des compréhensions de liste lorsque le produit final souhaité est une liste. Vous n'allez pas enregistrer de mémoire à l'aide d'expressions de générateur, car vous voulez la liste générée. Vous avez également l'avantage de pouvoir utiliser n'importe quelle fonction de liste comme triée ou inversée.

Par exemple:

reversed( [x*2 for x in xrange(256)] )

Lors de la création d'un générateur à partir d'un objet mutable (comme une liste), sachez que le générateur sera évalué sur l'état de la liste au moment de l'utilisation du générateur, et non au moment de la création du générateur:

>>> mylist = ["a", "b", "c"]
>>> gen = (elem + "1" for elem in mylist)
>>> mylist.clear()
>>> for x in gen: print (x)
# nothing

S'il y a une chance que votre liste soit modifiée (ou un objet modifiable à l'intérieur de cette liste) mais vous avez besoin de l'état à la création du générateur, vous devez utiliser une compréhension de liste à la place.

Parfois, vous pouvez vous en tirer avec la fonction tee d' itertools , elle renvoie plusieurs itérateurs pour le même générateur qui peuvent être utilisés indépendamment.

J'utilise le module Hadoop Mincemeat . Je pense que c'est un excellent exemple pour prendre note de:

import mincemeat

def mapfn(k,v):
    for w in v:
        yield 'sum',w
        #yield 'count',1


def reducefn(k,v): 
    r1=sum(v)
    r2=len(v)
    print r2
    m=r1/r2
    std=0
    for i in range(r2):
       std+=pow(abs(v[i]-m),2)  
    res=pow((std/r2),0.5)
    return r1,r2,res

Ici, le générateur extrait des nombres d'un fichier texte (aussi gros que 15 Go) et applique des calculs simples à ces nombres à l'aide de la réduction de carte de Hadoop. Si je n'avais pas utilisé la fonction de rendement, mais plutôt une compréhension de liste, il aurait fallu beaucoup plus de temps pour calculer les sommes et la moyenne (sans parler de la complexité de l'espace).

Hadoop est un excellent exemple pour utiliser tous les avantages des générateurs.