6.12. Seleksi dan penataan ulang

Reduksi menciutkan array menjadi skalar atau hasil berperingkat lebih rendah. Seleksi mencakup operasi yang memilih elemen mana yang bertahan dan di mana mereka berakhir: pilihan kondisional, pemotongan, pengurutan, pencarian indeks, pengurutan ulang sepanjang sebuah sumbu.

6.12.1. Pilihan kondisional

where() mengembalikan array yang mengambil elemen dari x di mana kondisinya benar dan dari y sebaliknya. Ketiga operand di-broadcast bersama-sama:

a = np.array([1, 2, 3, 4, 5], dtype=np.float)
np.where(a < 3, a, 0.0)
# array([1.0, 2.0, 0.0, 0.0, 0.0])

Ini adalah alat yang tepat untuk operasi "if/else per elemen" tanpa menulis loop Python.

clip() adalah singkatan dari maximum(lo, minimum(a, hi)) -- jenuhkan nilai ke dalam sebuah rentang:

np.clip(a, 2.0, 4.0)
# array([2.0, 2.0, 3.0, 4.0, 4.0])

maximum() dan minimum() mengambil dua operand dan mengembalikan yang lebih besar / lebih kecil per elemen:

np.maximum(a, 3.0)
np.minimum(a, np.array([5, 4, 3, 2, 1]))

6.12.2. Menemukan indeks

nonzero() mengembalikan koordinat setiap elemen bukan-nol, dibagi menjadi satu array indeks per dimensi. Untuk input 2-D, hasilnya adalah tuple dari dua array: yang pertama berisi indeks baris, yang kedua berisi indeks kolom. Memasangkan keduanya secara kolom memberikan (row, col) dari setiap posisi bukan-nol:

m = np.array([[0, 2, 0],
              [3, 0, 0]], dtype=np.float)
np.nonzero(m)
# (array([0, 1], dtype=uint16), array([1, 0], dtype=uint16))

Entri bukan-nol dalam m adalah m[0, 1] = 2 dan m[1, 0] = 3. Array pertama yang dikembalikan [0, 1] memberikan indeks barisnya; yang kedua [1, 0] memberikan indeks kolomnya. Membaca kedua array berdampingan memulihkan posisi (0, 1) dan (1, 0).

Dua reduksi juga menghasilkan indeks:

  • argmin() / argmax() -- indeks dari elemen terkecil / terbesar.

  • argsort() -- array integer yang akan mengurutkan input sepanjang sumbu yang diberikan (default ke yang terakhir):

    a = np.array([40, 10, 30, 20], dtype=np.uint8)
idx = np.argsort(a)             # array([1, 3, 2, 0], dtype=uint16)
a[idx]                          # array([10, 20, 30, 40])

    argsort selalu mengembalikan uint16; array yang diurutkan karena itu tidak boleh memiliki lebih dari 65.535 elemen pada sumbu yang diurutkan.

bincount() menghitung kemunculan setiap integer non-negatif dalam input uint8 / uint16 1-D:

histogram = np.bincount(np.array([0, 1, 1, 2, 2, 2], dtype=np.uint8))
# array([1, 2, 3], dtype=uint16)

Berguna untuk membangun histogram dari nilai piksel integer kecil tanpa menulis loop Python.

6.12.3. Pengurutan dan penataan ulang

sort() mengembalikan salinan array yang diurutkan sepanjang sumbu yang diberikan (terakhir secara default). Gunakan sort() langsung pada array untuk versi in-place:

np.sort(np.array([3, 1, 2], dtype=np.float))
# array([1.0, 2.0, 3.0])

flip() membalikkan urutan sepanjang sumbu yang diberikan (setiap sumbu ketika tidak ada axis yang diteruskan):

np.flip(np.array([1, 2, 3, 4]))
# array([4, 3, 2, 1])

roll() menggeser elemen secara siklik sebesar jumlah yang diberikan. Berguna untuk mengimplementasikan shift register bergaya ring-buffer:

np.roll(np.array([1, 2, 3, 4]), 1)
# array([4, 1, 2, 3])

take() adalah bentuk eksplisit dari fancy indexing -- pilih elemen pada indeks yang sewenang-wenang:

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.take(a, [0, 2, 4])
# array([10, 30, 50], dtype=uint8)

6.12.4. Penyaringan dan pengeditan struktural

compress() adalah bentuk eksplisit dari pengindeksan boolean -- kembalikan irisan a yang dipilih oleh kondisi boolean:

a = np.array([10, 20, 30, 40], dtype=np.uint8)
np.compress(a > 15, a)
# array([20, 30, 40], dtype=uint8)

delete() mengembalikan salinan dengan entri pada indeks yang diberikan dihapus:

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.delete(a, [1, 3])
# array([10, 30, 50], dtype=uint8)

diff() mengembalikan perbedaan maju diskrit ke-n dari array sepanjang sebuah sumbu. Digunakan untuk menghitung perubahan orde pertama antara sampel yang berdekatan:

samples = np.array([1, 3, 6, 10, 15], dtype=np.float)
np.diff(samples)
# array([2.0, 3.0, 4.0, 5.0])

6.12.5. Biaya setiap operasi

Hampir setiap fungsi di halaman ini mengembalikan array yang baru dialokasikan. Dua pengecualian:

  • sort() mengurutkan di tempat; fungsi bebas sort() mengembalikan salinan yang diurutkan.

  • take() menerima kata kunci out= untuk menulis ke dalam buffer yang sudah ada.

Dalam loop yang berjalan berkali-kali per detik, lebih baik menggunakan sort() in-place dan menggunakan kembali buffer yang sudah dialokasikan di tempat lain. Mask boolean sendiri dialokasikan setiap kali perbandingan dijalankan -- bangun mask sekali dan gunakan kembali di seluruh operasi daripada membangunnya kembali di dalam setiap iterasi.