Wie man Spalten in Numpy iterieren
Methode 1: Verwenden Sie für Schleife
In dieser Methode wird das 1-D-Array (dimensional) mit Hilfe der for-Schleife durchlaufen. Dies ist nur ein ähnlicher Weg wie die anderen Programmiersprachen C, C ++, Python usw.
ImportnumpyasnpArr = np.Arange (12)
Forvalinarr:
print (val, end = ")
Ausgang:
0 1 2 3 4 5 6 7 8 9 10 11Linie 1: Wir importieren die Numpy -Bibliothek als NP. Damit können wir diesen Namespace (NP) anstelle des vollständigen Namens Numpy verwenden.
Zeile 2: Wir haben eine Reihe von 12 Elementen erstellt, die wie unten aussehen:
Array ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])Zeile 3 bis 4: Wir verwenden jetzt eine für Schleife, um jedes Element des Arrays zu iterieren und diesen Elementwert zu drucken.
Methode 2: Verwenden Sie bei der Schleife
In dieser Methode wird das 1-D-Array (dimensional) mit Hilfe der while-Schleife iteriert.
ImportnumpyasnpArr = np.Arange (12)
I = 0
whilearr [i]
i = i+1
if (i == arr.Größe):
brechen
Ausgang:
01
2
3
4
5
6
7
8
9
10
11
Zeile 4 bis 8: In dieser Schleife setzt sich die Schleife bis zur Größe des Arrays fort (arr. Größe) ist geringer als der arr [i], da, wie wir wissen, der letzte Elementwert 11 und die Größe des Arrays 12 beträgt. Wenn die Bedingung wahr ist, drucken Sie dieses Element aus und erhöhen Sie die Iteration (i) Wert durch 1. Wenn die Anzahl der Iterationswert entspricht der Größe des Arrays, ruft und beendet der Pause die Schleife an. Der arr.Die Größe gibt die Anzahl der Elemente im Array zurück.
Methode 3: Iteriert ein zweidimensionales Array
Um das zweidimensionale Array zu iterieren, brauchen wir die verschachtelte Schleife. Aber wenn wir die Single für Schleife verwenden, dann iterieren wir nur über die Reihe.
Lassen Sie uns dies mit einem Beispiel verstehen.
Arr = np.Arange (12).Umschaffung (4,3)Für Row Inarr:
Druck (Zeile)
Ausgang:
[0 1 2][3 4 5]
[6 7 8]
[9 10 11]
Zeile 2 bis 3: Wir haben die Ausgabezeile in Bezug.
Mit der verschachtelten Schleife.
Arr = np.Arange (12).Umschaffung (4,3)Für Row Inarr:
Für Zelle in der Reihe:
print (Zelle, end = '\ t')
print ("\ n")
Ausgang:
0 1 23 4 5
6 7 8
9 10 11
Zeile 2 bis 5: Im obigen Programm verwenden wir zwei Schleifen, um ein 2-D-Array zu iterieren. Die erste Schleife nimmt den Zeilenwert aus dem ARR und die nächste Schleife greifen auf alle Elemente dieses Zeilenarrays zu und druckt auf dem Bildschirm, wie in der Ausgabe gezeigt.
Methode 4: Verwenden der Flachmethode
Eine andere Methode ist die abgefließte Methode. Die Abflachmethode wandelt das 2-D-Array in ein eindimensionales Array um. Wir brauchen keine zwei für Schleifen, um das 2-D-Array zu iterieren, wenn wir die Abflachmethode verwenden.
Arr = np.Arange (12).Umschaffung (4,3)für Cell Inarr.ebnen():
drucken (Zelle, End = ")
Ausgang:
0 1 2 3 4 5 6 7 8 9 10 11Zeile 2 bis 3: Die Flachung () -Methode hat das 2-D-Array in ein 1-D-Array umgewandelt, und wir iterieren es genauso wie das 1-D-Array. Hier müssen wir keine zwei für die Schleife verwenden.
Methode 5: Verwenden von Nditer -Objekt
Der Numpy bietet auch eine zusätzliche Methode, um das 2-D-Array zu iterieren. Diese Methode wird als NDiter -Methode bezeichnet. Im vorherigen Beispiel können wir auch mit der unten angegebenen NDiter -Methode versuchen:
Arr = np.Arange (12).Umschaffung (4,3)Für Cell Innp.Nditer (arr):
drucken (Zelle, End = ")
Ausgang:
0 1 2 3 4 5 6 7 8 9 10 11Zeile 2 bis 3: Wir übergeben unser Array an die Nditer () -Methode, und jetzt können wir auf jedes Element zugreifen, genau wie die Flachung () -Methode.
Nditer -Iterationsauftrag
Wir können auch die Zugriffsmethode des NDiter durch einen anderen Parameter bezeichnet. Wenn wir die Reihenfolge als C angeben, greifen die Nditer auf die horizontalen Elemente zu, und wenn wir die Reihenfolge als F angeben, greift sie vertikal auf die Elemente zu. Lassen Sie uns dies mit einem Beispiel für jede Bestellung verstehen.
Ordnung als C:
# C Bestell -IterationArr = np.Arange (12).Umschaffung (4,3)
Für Cell Innp.nditer (arr, order = 'c'):
drucken (Zelle, End = ")
Ausgang:
0 1 2 3 4 5 6 7 8 9 10 11Wenn wir nur den ARR drucken, erhalten wir die Ausgabe wie unten geben:
Array ([[0, 1, 2],[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
Jetzt, da wir die Nditer -Schleife mit der Reihenfolge als c verwenden. Es wird also horizontal auf die Elemente zugreifen. Wenn wir also in der obigen Array -Ausgabe sehen, sollten unsere Werte 0,1,2, 3, 4, 5 usw. betragen. Unser Ergebnis liegt also auch in derselben Reihenfolge, die zeigt, dass die Ordnung C horizontal funktioniert.
Ordnung als f:
# F Order IterationArr = np.Arange (12).Umschaffung (4,3)
Für Cell Innp.Nditer (arr, order = 'f'):
drucken (Zelle, End = ")
Ausgang:
0 3 6 9 1 4 7 10 2 5 8 11Wenn wir nur den ARR drucken, erhalten wir die Ausgabe wie unten geben:
Array ([[0, 1, 2],[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
Jetzt, da wir die Nditer -Schleife mit der Reihenfolge als f verwenden. Es wird also vertikal auf die Elemente zugreifen. Wenn wir also in der obigen Array -Ausgabe sehen, sollten unsere Werte 0,3,6,9, dann 1, 4, 7,10 usw. betragen. Unser Ergebnis ist also auch in derselben Reihenfolge, die zeigt, dass die Ordnung f vertikal funktioniert.
Methode 6: Modifikation zu den Werten von Numpy Array bei der Verwendung von NDiter
Standardmäßig behandelt der Nditer die Elemente des Arrays als schreibgeschützt, und wir können es nicht ändern. Wenn wir das versuchen, wird der Numpy einen Fehler aufwerfen.
Wenn wir jedoch die Werte des Numpy -Arrays bearbeiten möchten, müssen wir einen anderen Parameter namens op_flags = ['Readwrite' verwenden].
Lassen Sie uns dies mit einem Beispiel verstehen:
Für Cell Innp.Nditer (arr):Zelle […] = Zelle*2
Ausgang:
---------------------------------------------------------------------------ValueError Traceback (letzte Anruflast)
In
1FOR Cell Innp.Nditer (arr):
----> 2 Zelle […] = Zelle*2
ValueError: Zuweisungsziel ist schreibgeschützt
Mit OP_FLAGS = ['Readwrite'] Parameter.
Für Cell Innp.nditer (arr, op_flags = ['ReadWrite']):Zelle […] = Zelle-3
Arr
OUPUT:
Array ([[ -3, -2, -1],[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
Abschluss:
In diesem Artikel haben wir also alle Methoden untersucht, um das Numpy -Array zu iterieren. Die beste Methode ist Nditer. Diese NDiter -Methode ist fortgeschrittener, um die Numpy Array -Elemente zu verarbeiten. Hier in diesem Artikel werden alle grundlegenden Konzepte klar sein, und Sie können sich auch einige fortgeschrittenere Methoden des NDiter -wie Reduktions -Iteration ansehen. Dies sind die Methoden wie Reduktions -Iterationen, bei denen es sich um die Techniken handelt, um die Numpy -Array -Elemente in verschiedenen Formen zu bewältigen.
Der Code für diesen Artikel ist unter dem folgenden Link verfügbar:
https: // github.Com/Shekharpandey89/Numpy-Säulen-DIRTUMATIONS-Methoden