Angenommen, wir haben eine Liste mylist = ['a', 'b', 'c'], und wir wollen eine andere Liste wie folgt generieren: ['a:1', 'a:2', 'b:1', 'b:2', 'c:1', 'c:2'], die im Grunde ':1' und ':2' von mylist jedes Elemente anhängt.Anwenden von Konstanten in Liste Verständnis
Ich frage mich, wie dies effizient mit List Verständnis zu tun, wenn möglich?
So:
['%s:%d' % (e, i) for e in mylist for i in (1, 2)]
In [4]: mylist = ['a', 'b', 'c']
In [5]: list(itertools.chain.from_iterable([[e+":1", e+":2"] for e in mylist]))
Out[5]: ['a:1', 'a:2', 'b:1', 'b:2', 'c:1', 'c:2']
Netter Ansatz - es kam mir nicht (oder anscheinend irgendjemand anders) in den Sinn, das Produkt effektiv vorzurechnen. – Marcin
denke ich, der effizienteste Weg, dies zu tun ist mit itertools.product:
http://docs.python.org/2/library/itertools.html#itertools.product
from itertools import product
mylist = ['a', 'b', 'c']
mysuffixes = [':1', ':2']
result = [x+y for x, y in product(mylist, mysuffixes)]
Der genaue Aufbau kann variieren, je nachdem wie Ihre Konstanten sind definiert.
danke! Aber ich frage mich, wie effizient dieser ist, verglichen mit dem reinen Listenverständnis Ansatz von Mata oben? – MLister
Ein einfacher Test, den ich mit dem Modul 'timeit' eingerichtet habe, zeigt ihnen ungefähr dasselbe für eine 10000-Länge-Liste und eine 2-Längen-Suffix-Liste, die jedes Mal mit 1000 Wiederholungen getestet wird. Ich habe gesehen, dass jede der beiden Varianten die andere Version überboten hat - in der extremsten Version dauerte die Produktversion 3,11 Sekunden für 1000 Wiederholungen, während die Listenverständnisversion 4,57 benötigte. Auf der anderen Seite sah ich auch, dass die List Comprehension Version 3.26s nahm, während die Produktversion 4.08s benötigte. Dies ist keine genaue Analyse, aber es sieht so aus, als wäre der Geschwindigkeitsunterschied gering. –
Dieses Konzept ist das gleiche wie itertools.product
>>> from itertools import product
>>> list(product(mylist, ('1', '2')))
[('a', '1'), ('a', '2'), ('b', '1'), ('b', '2'), ('c', '1'), ('c', '2')]
Als Produktrück Tupel müssen Sie kommen, dass Tupel mit : denke ich, diese Lösung ist das deutlichste:
>>> map(':'.join, product(mylist, ('1', '2')))
['a:1', 'a:2', 'b:1', 'b:2', 'c:1', 'c:2']
>>> a=['a','b','c']
>>> b=[1,2]
>>> import itertools
>>> ['%s:%s' % (x,y) for x,y in itertools.product(a,b)]
['a:1', 'a:2', 'b:1', 'b:2', 'c:1', 'c:2']
Und jetzt denke ich, dass wir drei Antworten haben, die alle drei offensichtlichen Wege zeigen, die letzten Strings aus den Tupel 'itertools.product' rendite (String-Verkettung, String-Interpolation und' Join') zu konstruieren. –
-1 da Nested Loops in Comprehensions sind schwer zu verstehen und sind OP vielleicht nicht bekannt. – Marcin