powiedzmy mamy listę mylist = ['a', 'b', 'c'] i chcemy wygenerować kolejną listę takiego: ['a:1', 'a:2', 'b:1', 'b:2', 'c:1', 'c:2'], które zasadniczo dołącza ':1' i ':2' do każdego elementu mylist.Stosowanie stałe w listowego
Zastanawiam się, jak to zrobić skutecznie przy użyciu rozumienia list, jeśli to możliwe?
Jak to:
['%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']
Przyjemne podejście - nie przyszło mi (lub podobno nikomu innemu) skutecznie obliczyć produktu. – Marcin
Myślę, że najbardziej skutecznym sposobem na to jest z 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)]
Dokładna budowa może się różnić w zależności od sposobu twoje stałe są zdefiniowane.
dzięki! Zastanawiam się jednak, jak efektywny jest ten sposób porównywania z podejściem do rozumienia czystego listu przez Mata powyżej? – MLister
Jeden prosty test, który ustawiłem za pomocą modułu 'timeit' pokazuje je mniej więcej tak samo dla myli o długości 10000 i listy sufiksów o długości 2, testując za każdym razem 1000 powtórzeń. Zauważyłem, że każda z wersji pokonuje drugą, gdy jest uruchamiana jedna po drugiej - w wersji najbardziej ekstremalnej wersja produktu zajęła 3,11 sekundy dla 1000 powtórzeń, podczas gdy wersja ze zrozumieniem listy zajęła 4.57. Z drugiej strony widziałem również, że wersja ze zrozumieniem listy zajmuje 3,26 sekundy, podczas gdy wersja produktu zajęła 4.08s. Nie jest to dokładna analiza, ale wygląda na to, że każda różnica prędkości będzie niewielka. –
Ta koncepcja jest taka sama jak itertools.product
>>> from itertools import product
>>> list(product(mylist, ('1', '2')))
[('a', '1'), ('a', '2'), ('b', '1'), ('b', '2'), ('c', '1'), ('c', '2')]
Jak powraca produktów krotki trzeba dołączyć że krotki z : Myślę, że to rozwiązanie jest najwyraźniejszy:
>>> 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']
A teraz myślę, że mamy trzy odpowiedzi pokazujące wszystkie trzy oczywiste sposoby skonstruowania końcowych łańcuchów z krotności "wydajności itertools.product" (konkatenacja łańcuchów, interpolacja ciągów i 'join'). –
-1 ponieważ zagnieżdżone pętle w zrozumieniu są trudne do zrozumienia i mogą nie być znane w OP. – Marcin