Podwójna iteracja w rozumieniu listy

W Pythonie możesz mieć wiele iteratorów ze zrozumieniem listy, takich jak

[(x,y) for x in a for y in b]

dla niektórych odpowiednich sekwencji a i b. Zdaję sobie sprawę z semantyki zagnieżdżonej pętli w zrozumieniu list Pythona.

Moje pytanie brzmi: czy jeden iterator w rozumieniu może odnosić się do drugiego? Innymi słowy: czy mogę mieć coś takiego:

[x for x in a for a in b]

gdzie aktualna wartość zewnętrznej pętli jest iteratorem wewnętrznej?

Na przykład, jeśli mam listę zagnieżdżoną:

a=[[1,2],[3,4]]

jakie byłoby wyrażenie ze zrozumieniem listy, aby osiągnąć ten wynik:

[1,2,3,4]

?? (Proszę wymienić tylko odpowiedzi na zrozumienie, ponieważ właśnie tego chcę się dowiedzieć).

Aby odpowiedzieć na twoje pytanie własną sugestią:

>>> [x for b in a for x in b] # Works fine

Podczas gdy prosiłeś o odpowiedzi na listy, pozwól mi również wskazać doskonałą itertools.chain ():

>>> from itertools import chain
>>> list(chain.from_iterable(a))
>>> list(chain(*a)) # If you're using python < 2.6

Mam nadzieję, że to pomaga komuś innemu, ponieważ a,b,x,ynie ma dla mnie większego znaczenia! Załóżmy, że masz tekst pełen zdań i potrzebujesz szeregu słów.

# Without list comprehension
list_of_words = []
for sentence in text:
    for word in sentence:
       list_of_words.append(word)
return list_of_words

Lubię rozumieć listę jako rozciąganie kodu w poziomie.

Spróbuj podzielić to na:

# List Comprehension 
[word for sentence in text for word in sentence]

Przykład:

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> [word for sentence in text for word in sentence]
['Hi', 'Steve!', "What's", 'up?']

Działa to również w przypadku generatorów

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> gen = (word for sentence in text for word in sentence)
>>> for word in gen: print(word)
Hi
Steve!
What's
up?

Rany, chyba znalazłem odpowiedź: nie dbałem wystarczająco o to, która pętla jest wewnętrzna, a która zewnętrzna. Zrozumienie listy powinno wyglądać następująco:

[x for b in a for x in b]

aby uzyskać pożądany wynik, i tak, jedna bieżąca wartość może być iteratorem następnej pętli.

Kolejność iteratorów może wydawać się sprzeczna z intuicją.

Weź na przykład: [str(x) for i in range(3) for x in foo(i)]

Rozłóżmy to:

def foo(i):
    return i, i + 0.5

[str(x)
    for i in range(3)
        for x in foo(i)
]

# is same as
for i in range(3):
    for x in foo(i):
        yield str(x)

ThomasH dodał już dobrą odpowiedź, ale chcę pokazać, co się stanie:

>>> a = [[1, 2], [3, 4]]
>>> [x for x in b for b in a]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

>>> [x for b in a for x in b]
[1, 2, 3, 4]
>>> [x for x in b for b in a]
[3, 3, 4, 4]

Myślę, że Python analizuje zrozumienie listy od lewej do prawej. Oznacza to, że pierwsza forwystępująca pętla zostanie wykonana jako pierwsza.

Drugim „problemem” jest to, że b„wyciekają” ze zrozumienia listy. Po pierwszym udanym zrozumieniu listy b == [3, 4].

Jeśli chcesz zachować tablicę wielowymiarową, należy zagnieździć nawiasy tablicowe. patrz przykład poniżej, w którym jeden jest dodawany do każdego elementu.

>>> a = [[1, 2], [3, 4]]

>>> [[col +1 for col in row] for row in a]
[[2, 3], [4, 5]]

>>> [col +1 for row in a for col in row]
[2, 3, 4, 5]

Ta technika pamięci bardzo mi pomaga:

[ <RETURNED_VALUE> <OUTER_LOOP1> <INNER_LOOP2> <INNER_LOOP3> ... <OPTIONAL_IF> ]

A teraz możesz pomyśleć o R eturn + O u -loop, jako o jedynej R Oght O ania

Znając powyższe, kolejność w liście wyczerpująca nawet dla 3 pętli wydaje się łatwa:

c=[111, 222, 333]
b=[11, 22, 33]
a=[1, 2, 3]

print(
  [
    (i, j, k)                            # <RETURNED_VALUE> 
    for i in a for j in b for k in c     # in order: loop1, loop2, loop3
    if i < 2 and j < 20 and k < 200      # <OPTIONAL_IF>
  ]
)
[(1, 11, 111)]

ponieważ powyższe jest po prostu:

for i in a:                         # outer loop1 GOES SECOND
  for j in b:                       # inner loop2 GOES THIRD
    for k in c:                     # inner loop3 GOES FOURTH
      if i < 2 and j < 20 and k < 200:
        print((i, j, k))            # returned value GOES FIRST

w przypadku iteracji jednej zagnieżdżonej listy / struktury technika jest taka sama: az pytania:

a = [[1,2],[3,4]]
[i2    for i1 in a      for i2 in i1]
which return [1, 2, 3, 4]

dla siebie zagnieżdżony poziom

a = [[[1, 2], [3, 4]], [[5, 6], [7, 8, 9]], [[10]]]
[i3    for i1 in a      for i2 in i1     for i3 in i2]
which return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

i tak dalej

Wydaje mi się, że łatwiej to zrozumieć

[row[i] for row in a for i in range(len(a))]

result: [1, 2, 3, 4]

Dodatkowo, możesz użyć tej samej zmiennej dla elementu listy wejściowej, do którego jest aktualnie uzyskiwany dostęp, oraz dla elementu wewnątrz tego elementu. Może to jednak nawet uczynić go bardziej (listowym) niezrozumiałym.

input = [[1, 2], [3, 4]]
[x for x in input for x in x]

Najpierw for x in inputjest analizowany, co prowadzi do jednej listy członków danych wejściowych, następnie Python przechodzi przez drugą część, for x in xpodczas której wartość x jest nadpisywana przez bieżący element, do którego ma dostęp, a następnie pierwsza xokreśla, co chcemy zwrócić.

Ta funkcja flatten_nlevel wywołuje rekurencyjnie zagnieżdżoną listę1, aby ukryć się na jednym poziomie. Wypróbuj to

def flatten_nlevel(list1, flat_list):
    for sublist in list1:
        if isinstance(sublist, type(list)):        
            flatten_nlevel(sublist, flat_list)
        else:
            flat_list.append(sublist)

list1 = [1,[1,[2,3,[4,6]],4],5]

items = []
flatten_nlevel(list1,items)
print(items)

wynik:

[1, 1, 2, 3, 4, 6, 4, 5]