Come iterare le colonne in numpy
Metodo 1: usando per loop
In questo metodo iterirà l'array 1-D (dimensionale) con l'aiuto del loop per. Questo è solo un modo simile agli altri linguaggi di programmazione C, C ++, Python, ecc.
importnumpyasnpArr = np.Arange (12)
Forvalinarr:
Stampa (val, end = ")
Produzione:
0 1 2 3 4 5 6 7 8 9 10 11Linea 1: Importiamo la libreria Numpy come NP. In modo che possiamo usare questo spazio dei nomi (NP) invece del nome completo Numpy.
Linea 2: Abbiamo creato un array di 12 elementi che sembrano sotto:
Array ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])Riga da 3 a 4: Ora stiamo usando un ciclo per iterare ogni elemento dell'array e stampare quel valore dell'elemento.
Metodo 2: usando While Loop
In questo metodo iterirà l'array 1-D (dimensionale) con l'aiuto del ciclo while.
importnumpyasnpArr = np.Arange (12)
i = 0
mentre [i]
i = i+1
if (i == arr.misurare):
rottura
Produzione:
01
2
3
4
5
6
7
8
9
10
11
Riga da 4 a 8: In questo While Loop, il ciclo continua fino alle dimensioni dell'array (arr. dimensione) è inferiore all'arr [i] perché, come sappiamo, l'ultimo valore di elemento sarà 11 e la dimensione dell'array è 12. Se la condizione è vera, stampare quell'elemento e incrementare il valore di iterazione (i) di 1. Se il conteggio del valore di iterazione è uguale alla dimensione dell'array, allora l'interruzione chiamerà ed uscirà nel loop. L'arr.La dimensione restituirà il numero di elementi nell'array.
Metodo 3: iterando un array bidimensionale
Per iterare l'array bidimensionale, abbiamo bisogno del ciclo nidificato. Ma se utilizziamo il singolo per loop, allora iteliamo solo sulla riga.
Capiamolo con un esempio.
Arr = np.Arange (12).Reshape (4,3)per la riga inarr:
Stampa (riga)
Produzione:
[0 1 2][3 4 5]
[6 7 8]
[9 10 11]
Riga da 2 a 3: Abbiamo ottenuto la riga di output perché, con l'aiuto del singolo ciclo, non potremmo iterare ogni cella dell'array 2-D.
Usando il loop nidificato.
Arr = np.Arange (12).Reshape (4,3)per la riga inarr:
per cell in riga:
Stampa (cella, end = '\ t')
print ("\ n")
Produzione:
0 1 23 4 5
6 7 8
9 10 11
Riga da 2 a 5: Nel programma sopra, utilizziamo due loop per iterare un array 2-D. Il primo loop prende il valore di riga dall'ARR e il prossimo loop accede a tutti gli elementi di quell'array di riga e stampe sullo schermo come mostrato nell'output.
Metodo 4: utilizzando il metodo appiattito
Un altro metodo è il metodo appiattito. Il metodo appiattito converte l'array 2-D in un array monodimensionale. Non abbiamo bisogno di due per i loop per iterare l'array 2-D se usiamo il metodo appiattito.
Arr = np.Arange (12).Reshape (4,3)per cell Inarr.appiattire():
stampa (cell, end = ")
Produzione:
0 1 2 3 4 5 6 7 8 9 10 11Riga da 2 a 3: Il metodo appiattico () ha convertito l'array 2-D in un array 1-D e lo itechiamo proprio come fa l'array 1-D. Qui, non abbiamo bisogno di usarne due per loop.
Metodo 5: usando l'oggetto nditer
Il numpy fornisce anche un metodo aggiuntivo per iterare l'array 2-D. Questo metodo è chiamato metodo Nditer. Nell'esempio precedente, possiamo anche provare con il metodo Nditer come indicato di seguito:
Arr = np.Arange (12).Reshape (4,3)per Cell Innp.nditer (arr):
stampa (cell, end = ")
Produzione:
0 1 2 3 4 5 6 7 8 9 10 11Riga da 2 a 3: Passiamo il nostro array al metodo nditer () e ora possiamo accedere a ciascun elemento proprio come fa il metodo flatten ().
Ordine di iterazione Nditer
Possiamo anche controllare il metodo di accesso di Nditer con un altro parametro chiamato ordine. Se specifichiamo l'ordine come C, allora Nditer accede agli elementi orizzontali saggi e se specifichiamo l'ordine come F, allora accederà agli elementi verticalmente. Capiamolo con un esempio di ogni ordine.
Ordina come c:
# C Iterazione dell'ordineArr = np.Arange (12).Reshape (4,3)
per Cell Innp.nditer (arr, ordine = 'c'):
stampa (cell, end = ")
Produzione:
0 1 2 3 4 5 6 7 8 9 10 11Se, stampiamo solo l'ARR, otteniamo l'output come dare di seguito:
Array ([[0, 1, 2],[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
Ora, mentre usiamo il loop Nditer con l'ordine come C. Quindi, accederà agli elementi in orizzontale. Quindi, se vediamo nell'output dell'array sopra, i nostri valori dovrebbero essere 0,1,2, quindi 3, 4, 5 e così via. Quindi il nostro risultato è anche nella stessa sequenza, che mostra che l'ordine C funziona in orizzontale.
Ordina come F:
# F Ordina iterazioneArr = np.Arange (12).Reshape (4,3)
per Cell Innp.nditer (arr, ordine = 'f'):
stampa (cell, end = ")
Produzione:
0 3 6 9 1 4 7 10 2 5 8 11Se, stampiamo solo l'ARR, otteniamo l'output come dare di seguito:
Array ([[0, 1, 2],[3, 4, 5],
[6, 7, 8],
[9, 10, 11]])
Ora, mentre usiamo il loop Nditer con l'ordine come F. Quindi, accederà agli elementi verticalmente. Quindi, se vediamo nell'output dell'array sopra, i nostri valori dovrebbero essere 0,3,6,9, quindi 1, 4, 7,10 e così via. Quindi il nostro risultato è anche nella stessa sequenza, che mostra che l'ordine F funziona in verticale.
Metodo 6: modifica ai valori dell'array numpy quando si utilizza Nditer
Per impostazione predefinita, Nditer tratta gli elementi dell'array di sola lettura e non possiamo modificarlo. Se proviamo a farlo, il numpy aumenterà un errore.
Ma, se vogliamo modificare i valori dell'array numpy, allora dobbiamo usare un altro parametro chiamato op_flags = ['readwrite'].
Capiamolo con un esempio:
per Cell Innp.nditer (arr):cell […] = cell*2
Produzione:
---------------------------------------------------------------------------ValueRror Traceback (chiamata più recente Last)
In
1Per Cell Innp.nditer (arr):
----> 2 cell […] = cell*2
ValueRror: la destinazione dell'assegnazione è di sola lettura
Con op_flags = ['readwrite'] parametro.
per Cell Innp.nditer (arr, op_flags = ['readwrite'])cell […] = cell-3
Arr
Ouput:
Array ([[ -3, -2, -1],[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
Conclusione:
Quindi in questo articolo, abbiamo studiato tutti i metodi per iterare l'array numpy. Il metodo migliore è nditer. Questo metodo Nditer è più avanzato per gestire gli elementi dell'array numpy. Qui in questo articolo, tutti i concetti di base saranno chiari e puoi anche esaminare alcuni metodi più avanzati della Nditer come l'iterazione di riduzione. Questi sono metodi come le iterazioni di riduzione, che sono le tecniche per gestire gli elementi di array numpy in diverse forme.
Il codice per questo articolo è disponibile al link seguente:
https: // github.com/shekharpandey89/numpy-columns-iterations-methods