Doppelte Iteration beim Listenverständnis

In Python können Sie mehrere Iteratoren in einem Listenverständnis haben, wie z

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

für einige geeignete Sequenzen a und b. Mir ist die Semantik verschachtelter Schleifen in Pythons Listenverständnis bekannt.

Meine Frage ist: Kann sich ein Iterator im Verständnis auf den anderen beziehen? Mit anderen Worten: Könnte ich so etwas haben:

[x for x in a for a in b]

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

Wenn ich beispielsweise eine verschachtelte Liste habe:

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

Was wäre der Ausdruck für das Listenverständnis, um dieses Ergebnis zu erzielen:

[1,2,3,4]

?? (Bitte nur Verständnisantworten auflisten, da ich dies herausfinden möchte).

Um Ihre Frage mit Ihrem eigenen Vorschlag zu beantworten:

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

Während Sie nach Antworten zum Listenverständnis gefragt haben, möchte ich auch auf die hervorragenden itertools.chain () hinweisen:

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

Ich hoffe das hilft jemand anderem, da a,b,x,yich nicht viel Bedeutung habe! Angenommen, Sie haben einen Text voller Sätze 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 stelle mir Listenverständnis gerne als horizontales Strecken von Code vor.

Versuchen Sie es in:

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

Beispiel:

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

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

Ich glaube, ich habe die Antwort gefunden: Ich habe nicht genug darauf geachtet, welche Schleife innen und welche außen ist. Das Listenverständnis sollte wie folgt aussehen:

[x for b in a for x in b]

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

Die Reihenfolge der Iteratoren scheint möglicherweise nicht intuitiv zu sein.

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

Zerlegen wir es:

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 hat bereits eine gute Antwort hinzugefügt, aber ich möchte zeigen, was passiert:

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

Ich denke, Python analysiert das Listenverständnis von links nach rechts. Dies bedeutet, dass die erste auftretende forSchleife zuerst ausgeführt wird.

Das zweite "Problem" dabei ist, dass es baus dem Listenverständnis "durchgesickert" wird. Nach dem ersten erfolgreichen Listenverständnis b == [3, 4].

Wenn Sie das mehrdimensionale Array beibehalten möchten, sollten Sie die Array-Klammern verschachteln. Siehe Beispiel unten, in dem jedem Element eines hinzugefügt wird.

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

Diese Speichertechnik hilft mir sehr:

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

Und jetzt können Sie sich R eturn + O uter-loop als den einzigen R ight O rder vorstellen

Wie oben bekannt, scheint die Reihenfolge in der Liste, die auch für 3 Schleifen umfassend ist, einfach zu sein:

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

weil das obige 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 ist die Technik dieselbe: für aaus der Frage:

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

für einander 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

Ich denke, das ist leichter zu verstehen

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

result: [1, 2, 3, 4]

Darüber hinaus können Sie für das Mitglied der Eingabeliste, auf das derzeit zugegriffen wird, und für das Element in diesem Element dieselbe Variable verwenden . Dies könnte es jedoch noch verständlicher machen.

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

Zuerst for x in inputwird ausgewertet, was zu einer Mitgliederliste der Eingabe führt. Dann geht Python durch den zweiten Teil, for x in xin dem der x-Wert durch das aktuelle Element, auf das zugegriffen wird, überschrieben wird. Dann xdefiniert der erste, was wir zurückgeben möchten.

Diese Funktion flatten_nlevel ruft die verschachtelte Liste1 rekursiv auf, um sie auf eine Ebene zu verbergen. Probieren Sie es aus

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)

Ausgabe:

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