Подвійна ітерація в розумінні списку

У Python ви можете мати кілька ітераторів у розумінні списку, наприклад

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

для деяких підходящих послідовностей a і b. Мені відомо про семантику вкладених циклів розуміння списку Python.

Моє запитання: Чи може один ітератор у розумінні посилатися на інший? Іншими словами: Чи можу я мати щось подібне:

[x for x in a for a in b]

де поточне значення зовнішньої петлі є ітератором внутрішньої?

Як приклад, якщо у мене є вкладений список:

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

яким буде вираження розуміння списку для досягнення цього результату:

[1,2,3,4]

?? (Будь ласка, перерахуйте лише відповіді на розуміння, оскільки це я хочу дізнатися).

Щоб відповісти на запитання власною пропозицією:

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

Хоча ви запитували відповіді на розуміння списку, дозвольте мені також зазначити відмінний itertools.chain ():

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

Я сподіваюся, що це допомагає комусь іншому, оскільки a,b,x,yне має для мене великого значення! Припустимо, у вас є текст, повний речень, і ви хочете масив слів.

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

Мені подобається вважати розуміння списку як розтягування коду по горизонталі.

Спробуйте розбити його на:

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

Приклад:

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

Це також працює для генераторів

>>> 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?

Дуже, я вважаю, що я знайшов прихильника: я недостатньо піклувався про те, яка петля є внутрішньою, а яка зовнішньою. Розуміння списку має бути таким:

[x for b in a for x in b]

щоб отримати бажаний результат, і так, одне поточне значення може бути ітератором для наступного циклу.

Порядок ітераторів може здатися протиінтуїтивним.

Візьмемо для прикладу: [str(x) for i in range(3) for x in foo(i)]

Розберемо його:

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 вже додав хорошу відповідь, але я хочу показати, що відбувається:

>>> 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]

Я думаю, що Python аналізує розуміння списку зліва направо. Це означає, що перший forцикл, який виникає, буде виконаний першим.

Друга "проблема" цього полягає в тому, що вона b"просочується" із розуміння списку. Після першого успішного осмислення списку b == [3, 4].

Якщо ви хочете зберегти багатовимірний масив, слід вкласти дужки масивів. див. приклад нижче, де кожен додається до кожного елемента.

>>> 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]

Ця техніка пам'яті мені дуже допомагає:

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

А тепер ви можете подумати про R eturn + O маткову петлю як єдиний R іght O rder

Знаючи вище, порядок у списку є вичерпним навіть для 3-х циклів:

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)]

тому що вищезазначене - це лише:

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

для повторення одного вкладеного списку / структури, техніка однакова: для aпитання:

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

один для одного вкладений рівень

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]

і так далі

Я відчуваю, що це легше зрозуміти

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

result: [1, 2, 3, 4]

Крім того, ви можете використовувати лише ту саму змінну для члена вхідного списку, до якого зараз доступ, та для елемента всередині цього члена. Однак це може навіть зробити його (перелік) незрозумілішим.

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

Спочатку for x in inputоцінюється, ведучи до одного списку вхідних даних, потім, Python проходить через другу частину, for x in xпід час якої значення x перезаписується поточним елементом, до якого він отримує доступ, потім перший xвизначає, що ми хочемо повернути.

Ця функція flatten_nlevel викликає рекурсивно вкладений список1 для переходу на один рівень. Спробуйте це

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)

вихід:

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