Apakah Penyiaran NumPy?
Apabila melakukan operasi aritmetik pada tatasusunan bentuk yang berbeza, NumPy merujuknya sebagai penyiaran. Operasi tatasusunan ini kerap dijalankan pada elemen masing-masing. Jika dua tatasusunan mempunyai bentuk yang sama, ia boleh dilakukan pada mereka dengan mudah. Walaupun konsep ini berguna, penyiaran tidak selalu disyorkan kerana ia boleh mengakibatkan penggunaan memori yang tidak cekap yang melambatkan pengiraan. Operasi NumPy sering dilakukan pada pasangan tatasusunan yang dipecahkan elemen demi elemen.
Peraturan Penyiaran
Satu set garis panduan tertentu mesti dipatuhi semasa penyiaran. Ini diterangkan di bawah:
- Bentuk tatasusunan peringkat rendah adalah penting untuk ditambah dengan 1s sehingga kedua-dua bentuk tatasusunan berkongsi panjang yang sama jika dua tatasusunan tidak mempunyai kedudukan yang sama.
- Dua tatasusunan dianggap serasi jika ia mempunyai saiz dimensi yang sama atau jika salah satu daripadanya mempunyai saiz dimensi yang ditetapkan kepada 1.
- Tatasusunan hanya boleh disiarkan bersama jika saiz dan dimensinya sepadan.
- Setelah penyiaran selesai, setiap tatasusunan bertindak seolah-olah bentuknya sepadan dengan unsur terbesar dalam bentuk dua tatasusunan input.
- Salah satu tatasusunan berkelakuan seolah-olah ia direplikasi dengan dimensi itu jika tatasusunan lain mempunyai dimensi lebih besar daripada 1 dan tatasusunan pertama mempunyai dimensi 1.
Sekarang, mari kita bincangkan beberapa contoh pelaksanaan konsep penyiaran.
Contoh 1:
Pada pasangan tatasusunan, operasi NumPy biasanya dijalankan elemen demi elemen. Kedua-dua tatasusunan mesti, dalam senario yang paling mudah, mempunyai bentuk yang sama, seperti dalam contoh di bawah:
import numpy
one_arr = numpy. tatasusunan ( [ 2.0 , 3.0 , 1.0 ] )
dua_arr = numpy. tatasusunan ( [ 3.0 , 3.0 , 3.0 ] )
cetak ( satu_arr * dua_arr )
Seperti yang anda boleh lihat daripada kod di atas, kami mempunyai dua tatasusunan: ‘one_arr’ dan ‘two_ arr’. Setiap satunya mempunyai set nilai yang berasingan. Nilai dalam ‘one_arr’ ialah [2.0,3.0,1.0] dan ‘two _arr’ adalah [3.0,3.0,3.0]. Anda kemudiannya boleh melihat bahawa hasil pengiraan hasil darab kedua-dua tatasusunan ini adalah seperti berikut:
Apabila keperluan tertentu dipenuhi oleh borang tatasusunan, peraturan penyiaran NumPy merendahkan sekatan ini. Apabila tatasusunan dan nilai skalar digabungkan dalam operasi, penyiaran ditunjukkan dalam bentuk yang paling asas. Seperti yang anda lihat, 3 terkandung dalam pembolehubah bernama 'two_arr.'
import numpyone_arr = numpy. tatasusunan ( [ 2.0 , 3.0 , 1.0 ] )
dua_arr = 3.0
cetak ( satu_arr * dua_arr )
Kod di atas menghasilkan keputusan berikut.
Dalam contoh sebelumnya, apabila 'two_arr' ialah tatasusunan, hasilnya adalah setara. Kita mungkin membayangkan skalar 'two_arr' dikembangkan semasa proses aritmetik menjadi tatasusunan yang mempunyai bentuk yang sama seperti 'satu _arr.' Tatasusunan 'two_arr' mengandungi elemen baharu yang hanya pendua skalar pertama. Perbandingan regangan hanyalah hipotesis. Untuk menjadikan operasi penyiaran sebagai ingatan dan ekonomi pengiraan yang mungkin, NumPy cukup bijak untuk menggunakan nilai skalar asal dan bukannya menghasilkan salinan.
Contoh 2:
Berikut ialah satu lagi program Python mudah yang melaksanakan penyiaran. Sekali lagi, dua tatasusunan dicipta yang mengandungi nilai yang berbeza. Ia adalah perlu untuk membentuk semula 'first_arr' menjadi vektor lajur dengan bentuk 3 × 1 untuk mengira produk luar. Berikutan ini, siaran dilakukan terhadap 'second_arr' untuk memberikan hasil saiz 3×2, yang dikenali sebagai produk luar 'first_arr' dan 'second_arr.' Penyiaran ke 2×3 adalah mungkin kerana 'result_arr' mempunyai bentuk 2 ×3 serta bentuk (3,).
Selepas mengikuti semua langkah yang dinyatakan di atas, vektor mesti dimasukkan dalam setiap lajur matriks iaitu 'result_arr' dan 'second_arr.' Ini mempunyai dimensi 2×3 dan (2, ). Transposing 'result_arr' akan menghasilkan bentuk 3×2, yang kemudiannya boleh disiarkan melawan 'second_arr' untuk mendapatkan bentuk yang sama. Biasanya, transposing ini menghasilkan produk akhir dalam bentuk 2×3.
import numpyfirst_arr = numpy. tatasusunan ( [ 12 , 24 , 14 ] )
second_arr = numpy. tatasusunan ( [ lima belas , 22 ] )
cetak ( numpy. membentuk semula ( first_arr , ( 3 , 1 ) ) * second_arr )
result_arr = numpy. tatasusunan ( [ [ 12 , 22 , 31 ] , [ lima belas , 22 , Empat lima ] ] )
cetak ( result_arr + first_arr )
cetak ( ( result_arr. T + second_arr ) . T )
cetak ( result_arr + numpy. membentuk semula ( second_arr , ( dua , 1 ) ) )
cetak ( result_arr * dua )
Anda boleh melihat output di bawah.
Contoh 3:
Tatasusunan tiga dimensi boleh disiarkan menggunakan program Python berikut. Dalam contoh ini, dua tatasusunan bernama 'first_arr' dan 'second_arr' telah dijana. Tatasusunan 'first_arr' mengandungi nilai [4,13,26,12] dan 'second_arr' mengandungi nilai [32,67,45,17]. 2 dimensi tatasusunan awal membuat perbezaan. Jumlah tatasusunan pertama dan kedua akan ditunjukkan di bawah selepas kod telah dilaksanakan. Anda boleh melihat bahawa kami mempunyai tiga penyataan cetakan dalam kod, yang setiap satunya memaparkan teks ' Tatasusunan pertama:', ' Tatasusunan kedua' dan ' Tatasusunan ketiga:' secara bergilir-gilir. Jumlah dua tatasusunan yang baru dijana ini kemudiannya ditunjukkan.
import numpyfirst_arr = numpy. tatasusunan ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , Empat lima , 17 ] ] )
second_arr = numpy. tatasusunan ( [ 24 , Empat lima , 66 , 87 ] )
cetak ( ' \n Tatasusunan pertama: ' )
cetak ( first_arr )
cetak ( ' \n Tatasusunan kedua: ' )
cetak ( second_arr )
cetak ( ' \n Jumlah tatasusunan pertama dan kedua: ' )
jumlah_hasil = first_arr + second_arr ;
cetak ( jumlah_hasil )
Berikut ialah tangkapan skrin output kod yang diberikan.
Contoh 4:
Program Python terakhir yang menyiarkan tatasusunan tiga dimensi diberikan di sini. Dua tatasusunan ditentukan dalam program ini, yang pertama mempunyai tiga dimensi. Jumlah tatasusunan pertama dan kedua akan ditunjukkan seperti yang ditunjukkan di atas selepas kod telah dilaksanakan. Walaupun nilai dalam tatasusunan ini berbeza-beza, kod yang tinggal adalah sama seperti yang digunakan dalam contoh atur cara di atas.
import numpyfirst_arr = numpy. tatasusunan ( [ [ 12 , Empat lima , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ lima puluh , 40 , 18 , 26 ] ] )
second_arr = numpy. tatasusunan ( [ 12 , 44 , 22 , 12 ] )
cetak ( ' \n Tatasusunan pertama: ' )
cetak ( first_arr )
cetak ( ' \n Tatasusunan kedua: ' )
cetak ( second_arr )
cetak ( ' \n Jumlah tatasusunan pertama dan kedua: ' )
jumlah_hasil = first_arr + second_arr ;
cetak ( jumlah_hasil )
Anda boleh lihat dalam rajah di bawah bahawa tatasusunan 3-dimensi daripada tatasusunan pertama dibentangkan, diikuti dengan tatasusunan 2-dimensi daripada tatasusunan kedua dan hasil kedua-dua ini menggunakan prinsip penyiaran.
Kesimpulan
Artikel ini membincangkan penyiaran, konsep Python yang penting. Dalam NumPy, istilah 'penyiaran' merujuk kepada kapasiti untuk mengendalikan tatasusunan pelbagai bentuk semasa menjalankan operasi aritmetik yang kerap dilakukan. Subjek yang disebutkan di atas telah dibincangkan secara menyeluruh dengan pelbagai contoh. Artikel ini menggunakan contoh program yang disebutkan untuk menunjukkan cara menyiarkan pada tatasusunan 1-D, 2-D dan 3-D, masing-masing. Anda boleh cuba menjalankan contoh ini pada sistem anda dan melihat hasilnya untuk memahami dengan lebih baik bagaimana semuanya berfungsi secara umum.