Penapis Numpy

Penapis Numpy



Mengambil elemen atau mendapatkan elemen daripada sesetengah data dikenali sebagai penapisan. NumPy ialah pakej yang membolehkan kami membuat tatasusunan dan menyimpan sebarang jenis data dalam bentuk tatasusunan. Apabila ia datang untuk menapis dalam tatasusunan semasa bekerja dengan pakej NumPy yang disediakan oleh python, ia membolehkan kami menapis atau mendapatkan data daripada tatasusunan menggunakan fungsi terbina dalam yang disediakan oleh NumPy. Senarai indeks Boolean, senarai Boolean yang sepadan dengan kedudukan tatasusunan, boleh digunakan untuk menapis tatasusunan. Jika elemen dalam indeks tatasusunan adalah benar, ia akan disimpan dalam tatasusunan melainkan elemen itu dikecualikan daripada tatasusunan.

Katakan kita mempunyai data pelajar yang disimpan dalam bentuk tatasusunan dan kita ingin menapis pelajar yang gagal. Kami hanya akan menapis tatasusunan dan mengecualikan pelajar yang gagal dan tatasusunan baharu pelajar yang lulus akan diperolehi.

Langkah-langkah untuk menapis Array NumPy

Langkah 1: Mengimport modul NumPy.







Langkah 2: Mencipta tatasusunan.



Langkah 3: Tambah keadaan penapisan.



Langkah 4: Buat tatasusunan ditapis baharu.





Sintaks:

Terdapat pelbagai cara untuk menapis tatasusunan. Ia bergantung kepada keadaan penapis, seperti jika kita hanya mempunyai satu syarat atau kita mempunyai lebih daripada satu syarat.

Kaedah 1: Untuk Satu Syarat Kami Akan Mengikuti Sintaks Berikut

tatasusunan [ tatasusunan < syarat ]

Dalam sintaks yang disebutkan di atas, 'tatasusunan' ialah nama tatasusunan yang daripadanya kami akan menapis elemen. Dan syaratnya ialah keadaan di mana unsur ditapis dan operator '<' ialah tanda matematik yang mewakili kurang daripada. Ia adalah cekap untuk menggunakannya apabila kita hanya mempunyai satu syarat atau kenyataan.



Kaedah 2: Menggunakan Operator 'ATAU'.

tatasusunan [ ( tatasusunan < syarat1 ) | ( tatasusunan > syarat2 ) ]

Dalam kaedah ini, 'tatasusunan' ialah nama tatasusunan yang daripadanya kami akan menapis nilai dan syarat diserahkan kepadanya. Operator “|” digunakan untuk mewakili fungsi 'ATAU' yang bermaksud daripada kedua-dua keadaan, satu harus benar. Ia berguna apabila terdapat dua syarat.

Kaedah 3: Menggunakan Operator 'DAN'.

tatasusunan [ ( tatasusunan < syarat1 ) & ( tatasusunan > syarat2 ) ]

Dalam sintaks berikut, 'tatasusunan' ialah nama tatasusunan yang akan ditapis. Manakala, syarat akan menjadi keadaan seperti yang dibincangkan dalam sintaks di atas manakala operator yang digunakan '&' ialah operator AND, yang bermaksud kedua-dua syarat mestilah benar.

Kaedah 4: Menapis mengikut Nilai Tersenarai

tatasusunan [ cth. dalam1d ( tatasusunan , [ Senarai nilai ] ) ]

Dalam kaedah ini, kami meluluskan tatasusunan kami yang ditakrifkan 'np.in1d' yang digunakan untuk membandingkan dua tatasusunan sama ada unsur tatasusunan yang akan ditapis terdapat dalam tatasusunan lain atau tidak. Dan tatasusunan dihantar ke fungsi np.in1d ​​yang akan ditapis daripada tatasusunan yang diberikan.

Contoh # 01:

Sekarang, mari kita laksanakan kaedah yang dibincangkan di atas dalam contoh. Pertama, kami akan memasukkan perpustakaan NumPy kami yang disediakan oleh Python. Kemudian, kami akan mencipta tatasusunan bernama 'my_array' yang akan memegang nilai '2', '3', '1', '9', '3', '5', '6', dan '1'. Seterusnya, kami akan menghantar kod penapis kami iaitu “my_array[(my_array < 5)]” kepada print statement yang bermaksud kami sedang menapis nilai yang kurang daripada “5”. Dalam baris seterusnya, kami mencipta satu lagi tatasusunan nama 'tatasusunan' yang bertanggungjawab untuk mempunyai nilai '1', '2', '6', '3', '8', '1' dan '0'. Kepada penyataan cetakan, kami lulus syarat bahawa kami akan mencetak nilai yang lebih besar daripada 5.

Akhir sekali, kami mencipta tatasusunan lain yang kami namakan 'arr'. Ia memegang nilai '6', '7', '10', '12', dan '14'. Sekarang untuk tatasusunan ini, kami akan mencetak nilai yang tidak wujud dalam tatasusunan untuk melihat apa yang akan berlaku jika keadaan tidak sepadan. Untuk berbuat demikian, kami lulus syarat yang akan menapis nilai yang sama dengan nilai '5'.

import numpy sebagai cth.

my_array = cth. tatasusunan ( [ dua , 3 , 1 , 9 , 3 , 5 , dua , 6 , 1 ] )

cetak ( 'nilai kurang daripada 5' , my_array [ ( my_array < 5 ) ] )

tatasusunan = cth. tatasusunan ( [ 1 , dua , 6 , 3 , 8 , 1 , 0 ] )

cetak ( 'nilai lebih besar daripada 5' , tatasusunan [ ( tatasusunan > 5 ) ] )

arr = cth. tatasusunan ( [ 6 , 7 , 10 , 12 , 14 ] )

cetak ( 'nilai sama dengan 5' , arr [ ( arr == 5 ) ] )

Selepas melaksanakan kod, kami mempunyai output berikut sebagai hasilnya, di mana kami telah memaparkan 3 output yang pertama adalah untuk elemen kurang daripada '5' dalam pelaksanaan kedua kami mencetak nilai yang lebih besar daripada '5'. Pada akhirnya, kami mencetak nilai yang tidak wujud kerana kami dapat melihat ia tidak memaparkan sebarang ralat tetapi memaparkan tatasusunan kosong, yang bermaksud nilai yang dikehendaki tidak wujud dalam tatasusunan yang diberikan.

Contoh # 02:

Dalam contoh ini, kami akan menggunakan beberapa kaedah di mana kami boleh menggunakan lebih daripada satu syarat untuk menapis tatasusunan. Untuk melaksanakannya, kami hanya akan mengimport perpustakaan NumPy dan kemudian mencipta tatasusunan satu dimensi saiz '9' yang mempunyai nilai '24', '3', '12', '9', '3', '5', “2”, “6”, dan “7”. Dalam baris seterusnya, kami menggunakan pernyataan cetakan yang kami telah lulus tatasusunan yang telah kami mulakan dengan nama 'my_array' dengan syarat sebagai hujah. Dalam ini, kita telah melepasi syarat atau yang bermaksud daripada kedua-duanya, satu syarat mesti benar. Jika kedua-duanya adalah benar, ia akan memaparkan data untuk kedua-dua syarat. Dalam keadaan ini, kami ingin mencetak nilai yang kurang daripada '5' dan lebih besar daripada '9'. Dalam baris seterusnya, kami menggunakan operator AND untuk menyemak perkara yang akan berlaku jika kami menggunakan syarat untuk menapis tatasusunan. Dalam keadaan ini, kami memaparkan nilai yang lebih besar daripada '5' dan kurang daripada '9'.

Import numpy sebagai cth.

my_array = cth. tatasusunan ( [ 24 , 3 , 12 , 9 , 3 , 5 , dua , 6 , 7 ] )

cetak ( “nilai kurang daripada 5 atau lebih besar daripada 9 , my_array [ ( my_array < 5 ) | ( my_array > 9 ) ] )

cetak ( “nilai lebih besar daripada 5 dan kurang daripada 9 , my_array [ ( my_array > 5 ) & ( my_array < 9 ) ] )

Seperti yang ditunjukkan dalam coretan di bawah, hasil kami untuk kod di atas dipaparkan di mana kami menapis tatasusunan dan mendapat hasil berikut. Seperti yang kita lihat, nilai yang lebih besar daripada 9 dan kurang daripada 5 dipaparkan dalam output pertama dan nilai antara 5 dan 9 diabaikan. Manakala, dalam baris seterusnya, kami telah mencetak nilai antara '5' dan '9' iaitu '6' dan '7'. Nilai tatasusunan yang lain tidak dipaparkan.

Kesimpulan

Dalam panduan ini, kami telah membincangkan secara ringkas penggunaan kaedah penapis yang disediakan oleh pakej NumPy. Kami telah melaksanakan berbilang contoh untuk menghuraikan untuk anda tentang cara terbaik untuk melaksanakan metodologi penapis yang disediakan oleh numpy.