Sintaks
Sintaks untuk mencipta tatasusunan yang mengandungi nombor kompleks adalah seperti berikut:
Kaedah 1:
1j * np. arange ( saiz )Sintaks yang diberikan di atas 1j ialah bahagian khayalan yang bermaksud kita mencipta tatasusunan nombor kompleks, di mana np.arrang ialah fungsi yang disediakan oleh NumPy untuk mencipta tatasusunan kepada julat tertentu. Saiz, yang menunjukkan saiz tatasusunan, dihantar ke fungsi.
Kaedah 2:
cth. tatasusunan ( [ Re+Re*Im , Re+Re*Im , … ] )Dalam sintaks ini, np.arrray ialah fungsi yang membolehkan kita mencipta tatasusunan tetapi kita tidak boleh menghantar julat kepadanya. Kami hanya menghantar nilai kepadanya 'n' kali. Dalam fungsi tersebut, kami lulus 'Re' yang menunjukkan nombor nyata menambahkannya pada 'Im' nombor khayalan dalam gandaan nombor nyata. Kita boleh menghantar nilai khayalan kepada n kali.
Contoh # 01:
Seperti yang kita tahu NumPy juga menyokong nombor kompleks dan menyediakan pelbagai jenis kaedah untuk melaksanakan dan memanipulasi nombor kompleks. Dalam contoh di bawah, kami akan melaksanakan dua cara untuk mencipta tatasusunan yang mengandungi nombor kompleks. Untuk melaksanakan fungsi NumPy, mari kita mengimport perpustakaan NumPy dahulu sebagai np. Kemudian, kami akan memulakan tatasusunan bernama 'array_a' yang kami tetapkan fungsi np.arange() yang akan mengandungi nombor kompleks. Dan julat tatasusunan ialah '8'. Dalam baris seterusnya, kami mencipta tatasusunan lain bernama 'array_b' yang mana kami lulus tatasusunan nombor kompleks dengan menghantar nilai kompleks terus kepadanya. Pada akhirnya, kami mencetak tatasusunan kompleks yang kami buat menggunakan kedua-dua kaedah.
import numpy sebagai cth.
array_a = 1j * np. arange ( 8 )
array_b = cth. tatasusunan ( [ dua +1h , 3 +4j , 5 +2j , 1 +6j ] )
cetak ( 'tatasusunan kompleks menggunakan fungsi arange()' , array_a )
cetak ( 'tatasusunan kompleks menggunakan fungsi np.array()' , array_b )
Seperti yang ditunjukkan dalam coretan di bawah ialah hasil kod yang telah kami laksanakan. Kita dapat melihat bahawa kita telah mencipta dua tatasusunan yang mempunyai julat nombor kompleks dari 0j hingga 7j. Dalam satu lagi, kami telah melepasi julat rawak nombor kompleks bersaiz 4.
Kaedah 3:
cth. kompleks ( Re+Re*Im )Dalam sintaks yang diberikan di atas, np.complex() ialah kelas terbina dalam yang disediakan oleh pakej Python NumPy yang membolehkan kami menyimpan nilai kompleks.
Contoh # 02:
Cara lain untuk mencipta tatasusunan kompleks NumPy ialah menggunakan kelas complex() NumPy. Kelas kompleks() digunakan untuk menyimpan nombor kompleks dan mengembalikan objek kompleks yang boleh kita gunakan beberapa kali dalam kod tunggal. Sekarang melaksanakan kelas complex(), kami akan mengimport pakej Numpy kami dahulu. Kemudian, kami akan memulakan tatasusunan yang mana kami lulus kelas kompleks yang menggunakan asterisk '*' untuk menghantar objek kelas kompleks() yang kami luluskan '3+1j'. Menggunakan fungsi arrange(), kami mencipta tatasusunan saiz 5. Akhirnya, kami hanya memaparkan output kod di mana kami mencipta tatasusunan kompleks menggunakan kelas complex().
import numpy sebagai cth.tatasusunan = cth. kompleks ( 3 +1h ) *cth. arange ( 5 )
cetak ( 'tatasusunan kompleks menggunakan kelas np.complex()' , tatasusunan )
Seperti yang ditunjukkan dalam rajah di bawah, kami telah mencipta susunan nombor kompleks. Tetapi satu lagi perkara yang boleh kita perhatikan dalam rajah ialah nilai pemalar tidak dilaksanakan secara berturut-turut kerana kita telah menghantar '3+1j' ke kelas kompleks() yang bermaksud nombor tiga akan ditambah kepada setiap nilai pemalar seterusnya.
Kaedah 4:
cth. satu ( bentuk , dtype = tiada , pesanan = 'C' , * , suka = tiada )Dalam kaedah np.ones(), kami menentukan tatasusunan nombor kompleks menggunakan parameter dtype dalam tatasusunan NumPy. Np.ones() digunakan untuk mengembalikan tatasusunan baharu yang mengandungi 1s. Kepada fungsi np.ones(), kami lulus empat parameter 'bentuk', yang digunakan untuk menentukan bentuk tatasusunan sama ada '2', '3' atau yang lain. 'dtype' ialah jenis data. Dalam kes kami, kami akan menggunakan jenis data yang kompleks. 'Tertib' mentakrifkan sama ada tatasusunan adalah satu dimensi, dua atau berbilang dimensi.
Contoh # 03:
Mari kita laksanakan kaedah one() untuk mendapatkan idea yang lebih baik tentang cara ia berfungsi semasa menggunakan nombor kompleks. Untuk melaksanakan kaedah ini, mari kita mengimport pakej NumPy kami dahulu yang disediakan oleh Python. Seterusnya, kami akan mencipta tatasusunan yang mana kami akan lulus fungsi np.ones() yang kami luluskan dua parameter. Yang pertama ialah '4' yang bermaksud saiz tatasusunan akan menjadi 4 dan yang kedua ialah 'dtype' yang kompleks. Ini bermakna, kita akan mencipta tatasusunan nombor kompleks jenis data. Mendarab fungsi ones() dengan nilai”2” bermakna nombor sebenar kita akan menjadi “2”. Pada akhirnya, kami mencetak tatasusunan yang kami buat menggunakan pernyataan cetakan.
import numpy sebagai cth.tatasusunan = cth. satu ( 4 , dtype = kompleks ) * dua
cetak ( 'tatasusunan kompleks menggunakan fungsi np.ones()' , tatasusunan )
Seperti yang ditunjukkan di bawah, output kod kami dilaksanakan dengan jayanya di mana kami mempunyai tatasusunan satu dimensi yang mengandungi 4 nilai kompleks dengan nombor nyata 2.
Contoh # 04:
Mari kita laksanakan contoh lain di mana kita akan mencipta susunan nombor kompleks dan akan mencetak bahagian khayalan dan nyata bagi nombor kompleks. Kami akan mengimport pustaka NumPy dahulu, kemudian mencipta tatasusunan yang kami luluskan nilai kompleks '6' kepada tatasusunan bernama 'tatasusunan' iaitu '56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j”. Dalam baris seterusnya, kami hanya mencetak tatasusunan. Sekarang, kami mencetak nilai khayalan dan sebenar tatasusunan kompleks.
Numpy menyediakan fungsi terbina dalam untuk kedua-dua operasi yang ditunjukkan di bawah. Yang pertama untuk mendapatkan bahagian khayalan ialah 'array_name.imag' di mana nilai sebelum titik ialah tatasusunan yang mana kita perlu mendapatkan bahagian khayalan. Dan yang kedua untuk mendapatkan bahagian sebenar ialah 'array_name.real'. Dalam kes kami, nama tatasusunan ialah 'tatasusunan' jadi kami lulus pernyataan cetakan, nama tatasusunan dan kata kunci untuk mendapatkan kedua-dua elemen.
import numpy sebagai cth.tatasusunan = cth. tatasusunan ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
cetak ( 'Susun atur asal:x' , tatasusunan )
cetak ( 'Bahagian sebenar tatasusunan:' )
cetak ( tatasusunan . sebenar )
cetak ( 'Bahagian khayalan tatasusunan:' )
cetak ( tatasusunan . imag )
Seperti yang ditunjukkan dalam coretan di bawah, output di mana bahagian khayalan dan bahagian sebenar tatasusunan kompleks berjaya dilaksanakan. Di mana bahagian sebenar ialah '56', '27', '68', '120', dan '3'. Dan bahagian khayalan ialah '0's'.
Kesimpulan
Dalam artikel ini, kami telah membincangkan secara ringkas nombor kompleks dan cara kami boleh mencipta tatasusunan kompleks menggunakan fungsi terbina dalam NumPy. Kami menerangkan berbilang fungsi yang membolehkan kami membuat tatasusunan kompleks dengan melaksanakan berbilang contoh untuk memahami dengan lebih baik.