Doppelte Iteration beim Verstehen von Listen

Question

In Python kann man mehrere Iteratoren in einem Listenverständnis haben, wie

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

für einige geeignete Sequenzen a und b. Ich bin mir der verschachtelten Schleifensemantik von Pythons Listenauffassungen bewusst.

Meine Frage ist: Kann ein Iterator in der Comprehension auf den anderen verweisen? Mit anderen Worten: Könnte ich etwas wie dieses haben:

[x for x in a for a in b]

wobei der aktuelle Wert der äußeren Schleife der Iterator der inneren Schleife ist?

Wenn ich zum Beispiel eine verschachtelte Liste habe:

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

Wie würde der Ausdruck für das Listenverständnis lauten, um dieses Ergebnis zu erzielen?

[1,2,3,4]

?? (Bitte geben Sie nur verständliche Antworten an, denn das ist es, was ich herausfinden möchte).

Answer 1

Angenommen, Sie haben einen Text mit vielen Sätzen und möchten eine Reihe von Wörtern.

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

Ich betrachte das Verstehen von Listen gerne als horizontale Ausdehnung des Codes.

Versuchen Sie es aufzuteilen in:

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

Ejemplo:

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

Dies gilt auch für Generatoren

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

Answer 2

Um Ihre Frage mit Ihrem eigenen Vorschlag zu beantworten:

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

Da Sie nach Antworten zum Listenverständnis gefragt haben, möchte ich auch auf das ausgezeichnete itertools.chain() hinweisen:

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

Answer 3

Mensch, ich glaube, ich habe die Antwort gefunden: Ich habe nicht sorgfältig genug darauf geachtet, welche Schleife inner und welche äußer ist. Das Listenverständnis sollte wie folgt sein:

[x for b in a for x in b]

um das gewünschte Ergebnis zu erhalten, und ja, ein aktueller Wert kann der Iterator für die nächste Schleife sein.

Answer 4

Die Reihenfolge der Iteratoren mag kontra-intuitiv erscheinen.

Nehmen Sie zum Beispiel: [str(x) for i in range(3) for x in foo(i)]

Zerlegen wir sie:

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)

Answer 5

Diese Gedächtnistechnik hilft mir sehr:

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

Und jetzt können Sie darüber nachdenken R eturn + O uter-loop als einzige R ight O rder

Mit dem Wissen von oben, die Reihenfolge in der Liste umfassend auch für 3 Schleifen scheinen einfach:

---

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

---

denn das obige ist nur ein:

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

---

für die Iteration einer verschachtelten Liste/Struktur, die Technik ist dieselbe: für a aus der Frage:

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

für eine andere verschachtelte Ebene

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]

und so weiter