Schrieb diese Funktion in Python, das eine Matrix transponiert:

def transpose(m):
    height = len(m)
    width = len(m[0])
    return [ [ m[i][j] for i in range(0, height) ] for j in range(0, width) ]

Dabei wurde mir klar, dass ich nicht vollständig verstehe, wie einzelne für Schleifen verschachtelte Zeilen ausgeführt werden. Bitte helfen Sie mir beim Verständnis, indem Sie die folgenden Fragen beantworten:

  1. In welcher Reihenfolge wird diese for-Schleife ausgeführt?
  2. Wenn ich eine dreifach verschachtelte for-Schleife hätte, welche Reihenfolge würde sie ausführen?
  3. Was wäre gleich die gleiche nicht verschachtelte for-Schleife?

Gegeben,

[ function(i,j) for i,j in object ]
  1. Welcher Typ muss ein Objekt sein, um dieses für die Schleifenstruktur zu verwenden?
  2. In welcher Reihenfolge werden i und j Elementen im Objekt zugewiesen?
  3. Kann es durch eine andere for-Schleifenstruktur simuliert werden?
  4. Kann diese for-Schleife mit einer ähnlichen oder anderen Struktur für die Schleife verschachtelt werden? Und wie würde es aussehen?

Zusätzliche Informationen sind ebenfalls willkommen.

122
Asher Garland 9 Juni 2013 im 09:08

3 Antworten

Beste Antwort

Die beste Informationsquelle ist das offizielle Python-Tutorial zum Listenverständnis. Das Listenverständnis ist fast das gleiche wie für Schleifen (sicherlich kann jedes Listenverständnis als for-Schleife geschrieben werden), aber sie sind oft schneller als die Verwendung einer for-Schleife.

Schauen Sie sich dieses längere Listenverständnis aus dem Tutorial an (der Teil if filtert das Verständnis, nur Teile, die die if-Anweisung übergeben, werden an den letzten Teil des Listenverständnisses übergeben (hier (x,y)):

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Es ist genau das gleiche wie diese verschachtelte for-Schleife (und wie im Tutorial angegeben, beachten Sie, wie die Reihenfolge von for und if identisch ist).

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Der Hauptunterschied zwischen einem Listenverständnis und einer for-Schleife besteht darin, dass der letzte Teil der for-Schleife (wo Sie etwas tun) eher am Anfang als am Ende steht.

Weiter zu Ihren Fragen:

Welcher Typ muss ein Objekt sein, um dieses für die Schleifenstruktur zu verwenden?

Eine iterable. Jedes Objekt, das eine (endliche) Menge von Elementen erzeugen kann. Dazu gehören alle Container, Listen, Mengen, Generatoren usw.

In welcher Reihenfolge werden i und j Elementen im Objekt zugewiesen?

Sie werden in genau derselben Reihenfolge zugewiesen, in der sie aus jeder Liste generiert wurden, als wären sie in einer verschachtelten for-Schleife (für Ihr erstes Verständnis würden Sie 1 Element für i erhalten, dann jeden Wert von j, 2. Element in i, dann jeder Wert von j usw.)

Kann es durch eine andere for-Schleifenstruktur simuliert werden?

Ja, bereits oben gezeigt.

Kann diese for-Schleife mit einer ähnlichen oder anderen Struktur für die Schleife verschachtelt werden? Und wie würde es aussehen?

Sicher, aber es ist keine gute Idee. Hier finden Sie beispielsweise eine Liste mit Zeichenlisten:

[[ch for ch in word] for word in ("apple", "banana", "pear", "the", "hello")]
155
Anthony Geoghegan 25 Feb. 2015 im 15:26

Der folgende Code enthält die besten Beispiele für verschachtelte Schleifen. Wenn Sie zwei for-Schleifen verwenden, denken Sie bitte daran, dass die Ausgabe der ersten Schleife für die zweite Schleife eingegeben wird. Schleifenbeendigung auch wichtig bei Verwendung der verschachtelten Schleifen

for x in range(1, 10, 1):
     for y in range(1,x):
             print y,
        print
OutPut :
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
-1
iminiki 17 Sept. 2019 im 08:00

Möglicherweise interessieren Sie sich für itertools.product, das zurückgegeben wird Eine Iterable, die Tupel von Werten aus allen Iterables ergibt, die Sie übergeben. Das heißt, itertools.product(A, B) liefert alle Werte der Form (a, b), wobei die a Werte von A und die b Werte von B stammen. . Beispielsweise:

import itertools

A = [50, 60, 70]
B = [0.1, 0.2, 0.3, 0.4]

print [a + b for a, b in itertools.product(A, B)]

Dies druckt:

[50.1, 50.2, 50.3, 50.4, 60.1, 60.2, 60.3, 60.4, 70.1, 70.2, 70.3, 70.4]

Beachten Sie, dass das letzte an itertools.product übergebene Argument das "innere" ist. Im Allgemeinen ist itertools.product(a0, a1, ... an) gleich [(i0, i1, ... in) for in in an for in-1 in an-1 ... for i0 in a0]

28
Lynn 9 Juni 2013 im 10:13