Untuk array loop dengan python

Mengontrol Urutan Iterasi

Ada kalanya penting untuk mengunjungi elemen array dalam urutan tertentu, terlepas dari tata letak elemen dalam memori. Objek menyediakan parameter pesanan untuk mengontrol aspek iterasi ini. Defaultnya, dengan perilaku yang dijelaskan di atas, adalah order=’K’ untuk mempertahankan urutan yang ada. Ini dapat diganti dengan order='C' untuk order C dan order='F' untuk order Fortran

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Memodifikasi Nilai Array

Secara default, memperlakukan operan input sebagai objek read-only. Untuk dapat memodifikasi elemen array, Anda harus menentukan mode baca-tulis atau tulis-saja menggunakan tanda per-operan 'baca-tulis' atau 'tulis-tulis'

Nditer kemudian akan menghasilkan array buffer yang dapat ditulisi yang dapat Anda modifikasi. Namun, karena nditer harus menyalin data buffer ini kembali ke array asli setelah iterasi selesai, Anda harus memberi sinyal saat iterasi berakhir, dengan salah satu dari dua metode. Anda juga bisa

• menggunakan nditer sebagai pengelola konteks menggunakan pernyataan with, dan data sementara akan ditulis kembali saat konteks keluar

• panggil metode tutup iterator setelah selesai iterasi, yang akan memicu write-back

nditer tidak lagi dapat diulang setelah close dipanggil atau konteksnya keluar

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> with np.nditer(a, op_flags=['readwrite']) as it:
..    for x in it:
..        x[...] = 2 * x
...
>>> a
array([[ 0,  2,  4],
       [ 6,  8, 10]])

Jika Anda menulis kode yang perlu mendukung versi numpy yang lebih lama, perhatikan bahwa sebelum 1. 15, bukan manajer konteks dan tidak memiliki metode dekat. Sebaliknya itu bergantung pada destruktor untuk memulai writeback dari buffer

Menggunakan Loop Eksternal

Dalam semua contoh sejauh ini, elemen a disediakan oleh iterator satu per satu, karena semua logika perulangan bersifat internal ke iterator. Meskipun ini sederhana dan nyaman, ini tidak terlalu efisien. Pendekatan yang lebih baik adalah memindahkan loop terdalam satu dimensi ke dalam kode Anda, di luar iterator. Dengan cara ini, operasi vektorisasi NumPy dapat digunakan pada bagian yang lebih besar dari elemen yang dikunjungi

The akan mencoba memberikan potongan yang sebesar mungkin ke loop dalam. Dengan memaksakan urutan 'C' dan 'F', kami mendapatkan ukuran loop eksternal yang berbeda. Mode ini diaktifkan dengan menentukan flag iterator

Perhatikan bahwa dengan default menjaga urutan memori asli, iterator mampu menyediakan satu potongan satu dimensi, sedangkan saat memaksa urutan Fortran, iterator harus menyediakan tiga potongan dari dua elemen masing-masing.

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, flags=['external_loop']):
..     print(x, end=' ')
...
[0 1 2 3 4 5]

>>> for x in np.nditer(a, flags=['external_loop'], order='F'):
..     print(x, end=' ')
...
[0 3] [1 4] [2 5]

Melacak Indeks atau Multi-Indeks

Selama iterasi, Anda mungkin ingin menggunakan indeks elemen saat ini dalam perhitungan. Misalnya, Anda mungkin ingin mengunjungi elemen array dalam urutan memori, tetapi gunakan indeks C-order, Fortran-order, atau multidimensi untuk mencari nilai dalam array yang berbeda

Indeks dilacak oleh objek iterator itu sendiri, dan dapat diakses melalui properti index atau multi_index, tergantung pada apa yang diminta. Contoh di bawah menunjukkan cetakan yang menunjukkan perkembangan indeks

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> it = np.nditer(a, flags=['f_index'])
>>> for x in it:
..     print("%d <%d>" % (x, it.index), end=' ')
...
0 <0> 1 <2> 2 <4> 3 <1> 4 <3> 5 <5>

>>> it = np.nditer(a, flags=['multi_index'])
>>> for x in it:
..     print("%d <%s>" % (x, it.multi_index), end=' ')
...
0 <(0, 0)> 1 <(0, 1)> 2 <(0, 2)> 3 <(1, 0)> 4 <(1, 1)> 5 <(1, 2)>

>>> with np.nditer(a, flags=['multi_index'], op_flags=['writeonly']) as it:
..     for x in it:
..         x[...] = it.multi_index[1] - it.multi_index[0]
...
>>> a
array([[ 0,  1,  2],
       [-1,  0,  1]])

Melacak indeks atau multi-indeks tidak kompatibel dengan penggunaan loop eksternal, karena memerlukan nilai indeks yang berbeda per elemen. Jika Anda mencoba menggabungkan flag-flag ini, objek akan memunculkan pengecualian

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Alternatif Looping dan Akses Elemen

Untuk membuat propertinya lebih mudah diakses selama iterasi, memiliki sintaks alternatif untuk iterasi, yang bekerja secara eksplisit dengan objek iterator itu sendiri. Dengan konstruksi perulangan ini, nilai saat ini dapat diakses dengan mengindeks ke dalam iterator. Properti lainnya, seperti indeks terlacak tetap seperti sebelumnya. Contoh di bawah menghasilkan hasil yang identik dengan yang ada di bagian sebelumnya

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Buffer Elemen Array

Saat memaksakan urutan iterasi, kami mengamati bahwa opsi loop eksternal dapat menyediakan elemen dalam potongan yang lebih kecil karena elemen tidak dapat dikunjungi dalam urutan yang sesuai dengan langkah konstan. Saat menulis kode C, ini umumnya baik-baik saja, namun dalam kode Python murni ini dapat menyebabkan penurunan kinerja yang signifikan

Dengan mengaktifkan mode buffering, potongan yang disediakan oleh iterator ke loop dalam dapat dibuat lebih besar, secara signifikan mengurangi overhead juru bahasa Python. Dalam contoh memaksa urutan iterasi Fortran, loop dalam dapat melihat semua elemen sekaligus saat buffering diaktifkan

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Iterasi sebagai Tipe Data Spesifik

Ada kalanya perlu memperlakukan array sebagai tipe data yang berbeda dari yang disimpan. Misalnya, seseorang mungkin ingin melakukan semua perhitungan pada pelampung 64-bit, bahkan jika array yang dimanipulasi adalah pelampung 32-bit. Kecuali saat menulis kode C level rendah, umumnya lebih baik membiarkan iterator menangani penyalinan atau buffering daripada memasukkan sendiri tipe data di loop dalam

Ada dua mekanisme yang memungkinkan hal ini dilakukan, salinan sementara dan mode buffering. Dengan salinan sementara, salinan seluruh array dibuat dengan tipe data baru, kemudian dilakukan iterasi dalam salinan tersebut. Akses tulis diizinkan melalui mode yang memperbarui larik asli setelah semua iterasi selesai. Kelemahan utama dari salinan sementara adalah bahwa salinan sementara dapat menghabiskan banyak memori, terutama jika tipe data iterasi memiliki ukuran item yang lebih besar daripada yang asli.

Mode buffer mengurangi masalah penggunaan memori dan lebih ramah cache daripada membuat salinan sementara. Kecuali untuk kasus khusus, di mana seluruh array diperlukan sekaligus di luar iterator, buffering direkomendasikan daripada penyalinan sementara. Di dalam NumPy, buffering digunakan oleh ufuncs dan fungsi lainnya untuk mendukung input fleksibel dengan overhead memori minimal

Dalam contoh kita, kita akan memperlakukan larik input dengan tipe data yang kompleks, sehingga kita dapat mengambil akar kuadrat dari bilangan negatif. Tanpa mengaktifkan mode penyalinan atau buffering, iterator akan memunculkan pengecualian jika tipe data tidak cocok dengan tepat

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Dalam mode penyalinan, 'copy' ditentukan sebagai flag per-operan. Hal ini dilakukan untuk memberikan kontrol dalam mode per-operan. Mode buffering ditentukan sebagai flag iterator

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Iterator menggunakan aturan casting NumPy untuk menentukan apakah konversi tertentu diizinkan. Secara default, ini memberlakukan transmisi 'aman'. Ini berarti, misalnya, akan memunculkan pengecualian jika Anda mencoba memperlakukan array float 64-bit sebagai array float 32-bit. Dalam banyak kasus, aturan 'same_kind' adalah aturan yang paling masuk akal untuk digunakan, karena akan memungkinkan konversi dari float 64 ke 32-bit, tetapi tidak dari float ke int atau dari kompleks ke float

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Satu hal yang harus diperhatikan adalah konversi kembali ke tipe data asli saat menggunakan operan baca-tulis atau hanya-tulis. Kasus yang umum adalah mengimplementasikan loop dalam dalam hal float 64-bit, dan menggunakan casting 'same_kind' untuk memungkinkan tipe floating-point lainnya diproses juga. Sementara dalam mode read-only, array integer dapat disediakan, mode read-write akan memunculkan pengecualian karena konversi kembali ke array akan melanggar aturan casting

Contoh

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Output Array yang Dialokasikan Iterator

Kasus umum dalam fungsi NumPy adalah memiliki keluaran yang dialokasikan berdasarkan penyiaran masukan, dan tambahan memiliki parameter opsional yang disebut 'keluar' di mana hasilnya akan ditempatkan saat disediakan. Objek menyediakan idiom yang nyaman yang membuatnya sangat mudah untuk mendukung mekanisme ini

Kami akan menunjukkan cara kerjanya dengan membuat fungsi yang mengkuadratkan inputnya. Mari kita mulai dengan definisi fungsi minimal yang tidak termasuk dukungan parameter 'keluar'

Contoh

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Secara default, menggunakan flag 'mengalokasikan' dan 'menulis' untuk operan yang diteruskan sebagai Tidak Ada. Ini berarti kami dapat memberikan hanya dua operan ke iterator, dan menangani sisanya

Saat menambahkan parameter 'keluar', kita harus secara eksplisit memberikan flag tersebut, karena jika seseorang meneruskan array sebagai 'keluar', iterator akan default ke 'hanya baca', dan loop dalam kita akan gagal. Alasan 'readonly' adalah default untuk array input adalah untuk mencegah kebingungan tentang memicu operasi pengurangan secara tidak sengaja. Jika defaultnya adalah 'baca tulis', setiap operasi penyiaran juga akan memicu pengurangan, topik yang dibahas nanti dalam dokumen ini

Sementara kita melakukannya, mari kita perkenalkan juga bendera 'no_broadcast', yang akan mencegah output disiarkan. Ini penting, karena kita hanya menginginkan satu nilai input untuk setiap output. Menggabungkan lebih dari satu nilai masukan merupakan operasi pengurangan yang memerlukan penanganan khusus. Itu sudah akan menimbulkan kesalahan karena pengurangan harus diaktifkan secara eksplisit dalam bendera iterator, tetapi pesan kesalahan yang dihasilkan dari penonaktifan penyiaran jauh lebih mudah dipahami oleh pengguna akhir. Untuk melihat cara menggeneralisasikan fungsi kuadrat menjadi pengurangan, lihat fungsi penjumlahan kuadrat di bagian tentang Cython

Untuk kelengkapan, kami juga akan menambahkan bendera 'external_loop' dan 'buffered', karena inilah yang biasanya Anda inginkan untuk alasan kinerja

Contoh

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Iterasi Produk Luar

Setiap operasi biner dapat diperluas ke operasi array dengan cara produk luar seperti in , dan objek menyediakan cara untuk melakukannya dengan secara eksplisit memetakan sumbu operan. Dimungkinkan juga untuk melakukan ini dengan pengindeksan, tetapi kami akan menunjukkan kepada Anda bagaimana cara langsung menggunakan parameter nditer op_axes untuk melakukannya tanpa tampilan perantara

Kami akan melakukan produk luar sederhana, menempatkan dimensi operan pertama sebelum dimensi operan kedua. Parameter op_axes memerlukan satu daftar sumbu untuk setiap operan, dan menyediakan pemetaan dari sumbu iterator ke sumbu operan

Misalkan operan pertama adalah satu dimensi dan operan kedua adalah dua dimensi. Iterator akan memiliki tiga dimensi, jadi op_axes akan memiliki dua daftar 3 elemen. Daftar pertama mengambil satu sumbu dari operan pertama, dan -1 untuk sumbu iterator lainnya, dengan hasil akhir [0, -1, -1]. Daftar kedua memilih dua sumbu dari operan kedua, tetapi tidak boleh tumpang tindih dengan sumbu yang dipilih di operan pertama. Daftarnya adalah [-1, 0, 1]. Operan keluaran memetakan ke sumbu iterator dengan cara standar, sehingga kami dapat menyediakan Tidak ada alih-alih membuat daftar lain

Operasi di loop dalam adalah perkalian langsung. Segala sesuatu yang berkaitan dengan produk luar ditangani oleh pengaturan iterator

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Perhatikan bahwa setelah iterator ditutup, kami tidak dapat mengakses dan harus menggunakan referensi yang dibuat di dalam pengelola konteks

Pengurangan Iterasi

Setiap kali operan yang dapat ditulisi memiliki lebih sedikit elemen daripada ruang iterasi penuh, operan tersebut mengalami pengurangan. Objek mengharuskan setiap operan reduksi ditandai sebagai baca-tulis, dan hanya mengizinkan reduksi ketika 'reduce_ok' disediakan sebagai flag iterator

Sebagai contoh sederhana, pertimbangkan untuk mengambil jumlah semua elemen dalam sebuah array

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Hal-hal sedikit lebih rumit saat menggabungkan reduksi dan operan yang dialokasikan. Sebelum iterasi dimulai, setiap operan reduksi harus diinisialisasi ke nilai awalnya. Inilah cara kita melakukannya, mengambil jumlah sepanjang sumbu terakhir dari a

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Untuk melakukan buffered reduction memerlukan penyesuaian lain selama penyiapan. Biasanya konstruksi iterator melibatkan penyalinan buffer data pertama dari array yang dapat dibaca ke dalam buffer. Setiap operan reduksi dapat dibaca, sehingga dapat dibaca ke dalam buffer. Sayangnya, inisialisasi operan setelah operasi buffering ini selesai tidak akan tercermin dalam buffer tempat iterasi dimulai, dan hasil sampah akan dihasilkan

Bendera iterator "delay_bufalloc" ada untuk memungkinkan operan pengurangan yang dialokasikan iterator ada bersama dengan buffering. Saat flag ini disetel, iterator akan membiarkan buffernya tidak diinisialisasi hingga menerima reset, setelah itu iterator akan siap untuk iterasi reguler. Beginilah tampilan contoh sebelumnya jika kita juga mengaktifkan buffering

Contoh

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5