Sintakse
Sintakse, lai izveidotu kompleksus skaitļus saturošu masīvu, ir šāda:
1. metode:
1j * np. sakārtot ( Izmērs )Sintakse, kas norādīta iepriekš 1j, ir iedomātā daļa, kas nozīmē, ka mēs veidojam komplekso skaitļu masīvu, kur np.arrang ir funkcija, ko nodrošina NumPy, lai izveidotu masīvu noteiktā diapazonā. Lielums, kas norāda masīva lielumu, tiek nodots funkcijai.
2. metode:
piem. masīvs ( [ Re+Re*Im , Re+Re*Im , … ] )Šajā sintaksē np.arrray ir funkcija, kas ļauj izveidot masīvu, taču mēs nevaram tam nodot diapazonu. Mēs vienkārši nododam vērtības tam “n” reizes. Funkcijā mēs nodevām “Re”, kas norāda reālus skaitļus, pievienojot tos “Im” iedomātam skaitlim, kas ir reāla skaitļa reizinājums. Iedomātās vērtības varam nodot n reizēm.
01. piemērs:
Kā mēs zinām, NumPy atbalsta arī kompleksos skaitļus un nodrošina vairākas metodes komplekso skaitļu ieviešanai un manipulēšanai ar tiem. Tālāk esošajā piemērā mēs ieviesīsim divus veidus, kā izveidot masīvus, kas satur kompleksos skaitļus. Lai ieviestu NumPy funkcijas, vispirms importēsim NumPy bibliotēku kā np. Pēc tam mēs inicializēsim masīvu ar nosaukumu “masīvs_a”, kuram piešķiram funkciju np.arange(), kas saturēs kompleksos skaitļus. Un masīva diapazons būs “8”. Nākamajā rindā mēs izveidojām citu masīvu ar nosaukumu “masīvs_b”, kuram mēs nosūtījām komplekso skaitļu masīvu, tieši nosūtot tam kompleksās vērtības. Galu galā mēs izdrukājām sarežģīto masīvu, ko izveidojām, izmantojot abas metodes.
imports nejutīgs kā piem.
masīvs_a = 1j * np. sakārtot ( 8 )
masīvs_b = piem. masīvs ( [ divi +1d , 3 +4j , 5 +2j , 1 +6j ] )
drukāt ( 'komplekss masīvs, izmantojot funkciju arange()' , masīvs_a )
drukāt ( 'komplekss masīvs, izmantojot funkciju np.array()' , masīvs_b )
Kā parādīts tālāk esošajā fragmentā, tas ir mūsu izpildītā koda rezultāts. Mēs redzam, ka esam izveidojuši divus masīvus, kuriem ir komplekso skaitļu diapazons no 0j līdz 7j. Otrā mēs esam izturējuši nejaušu komplekso skaitļu diapazonu, kura lielums ir 4.
3. metode:
piem. komplekss ( Re+Re*Im )Iepriekš norādītajā sintaksē np.complex() ir iebūvētā klase, ko nodrošina Python pakotne NumPy, kas ļauj saglabāt sarežģītas vērtības.
02. piemērs:
Vēl viens veids, kā izveidot NumPy komplekso masīvu, ir izmantot NumPy kompleksu () klasi. Kompleksā klase () tiek izmantota, lai saglabātu kompleksos skaitļus un atgriež komplekso objektu, ko mēs varam izmantot vairākas reizes vienā kodā. Tagad, ieviešot kompleksu () klasi, mēs vispirms importēsim savu Numpy pakotni. Pēc tam mēs inicializēsim masīvu, kuram mēs nodevām kompleksu klasi, kas izmanto zvaigznīti “*”, lai nodotu kompleksa () klases objektu, kuram mēs nodevām “3+1j”. Izmantojot funkciju arrange(), mēs izveidojām 5. izmēra masīvu. Beidzot mēs tikko parādījām koda izvadi, kurā izveidojām kompleksu masīvu, izmantojot kompleksu() klasi.
imports nejutīgs kā piem.masīvs = piem. komplekss ( 3 +1d ) *piem. sakārtot ( 5 )
drukāt ( 'komplekss masīvs, izmantojot np.complex() klasi' , masīvs )
Kā parādīts attēlā zemāk, mēs esam izveidojuši komplekso skaitļu masīvu. Bet vēl viena lieta, ko mēs varam pamanīt attēlā, ir tāda, ka konstantā vērtība netiek izpildīta secīgi, jo mēs esam nodevuši “3+1j” kompleksai () klasei, kas nozīmē, ka katrai nākamajai konstantei vērtībai tiks pievienots skaitlis trīs.
4. metode:
piem. vieni ( forma , dtype = Nav , pasūtījums = 'C' , * , patīk = Nav )Izmantojot šo metodi np.ones(), mēs norādām komplekso skaitļu masīvu, izmantojot parametru dtype masīvā NumPy. Np.ones() tiek izmantots, lai atgrieztu jaunu masīvu, kurā ir 1. Funkcijai np.ones() mēs nodevām četrus parametrus 'shape', ko izmanto, lai definētu masīva formu neatkarīgi no tā, vai tā ir '2', '3' vai cita. “dtype” ir datu tips. Mūsu gadījumā mēs izmantosim sarežģītu datu tipu. “Kārtība” nosaka, vai masīvs ir viendimensijas, divu vai daudzdimensiju.
03. piemērs:
Ieviesīsim ones() metodi, lai iegūtu labāku priekšstatu par tās darbību, izmantojot kompleksos skaitļus. Lai ieviestu šo metodi, vispirms importēsim mūsu Python nodrošinātās NumPy pakotnes. Tālāk mēs izveidosim masīvu, kuram nodosim funkciju np.ones(), kurai nodevām divus parametrus. Pirmais ir “4”, kas nozīmē, ka masīva lielums būs 4, bet otrais ir “dtype”, kas ir sarežģīts. Tas nozīmē, ka mēs izveidosim datu tipa komplekso skaitļu masīvu. Funkciju ones() reizinot ar vērtību '2', mūsu reālais skaitlis būs '2'. Beigās mēs izdrukājām masīvu, ko izveidojām, izmantojot drukāšanas paziņojumu.
imports nejutīgs kā piem.masīvs = piem. vieni ( 4 , dtype = komplekss ) * divi
drukāt ( 'komplekss masīvs, izmantojot funkciju np.ones()' , masīvs )
Kā parādīts zemāk, mūsu koda izvade ir veiksmīgi izpildīta, kurā mums ir viendimensijas masīvs, kas satur 4 sarežģītas vērtības ar reālo skaitli 2.
04. piemērs:
Tagad īstenosim citu piemēru, kurā izveidosim komplekso skaitļu masīvu un izdrukāsim komplekso skaitļu iedomātās un reālās daļas. Vispirms mēs importēsim NumPy bibliotēku, pēc tam izveidosim masīvu, kuram mēs nodevām “6” kompleksās vērtības masīvam ar nosaukumu “masīvs”, kas ir “56+0j, 27+0j, 68+0j, 49+0j, 120+0j”. , 4+0j”. Nākamajā rindā mēs vienkārši izdrukājām masīvu. Tagad mēs drukājam iedomātas un reālās kompleksā masīva vērtības.
Numpy nodrošina iebūvētu funkciju abām tālāk norādītajām darbībām. Pirmais, kas iegūst iedomāto daļu, ir “masīva_nosaukums.imags”, kur vērtība pirms punkta ir masīvs, no kura mums jāiegūst iedomātā daļa. Un otrais, lai iegūtu reālo daļu, ir “masīva_nosaukums.real”. Mūsu gadījumā masīva nosaukums ir “masīvs”, tāpēc mēs nodevām drukas paziņojumu, masīva nosaukumu un atslēgvārdu, lai iegūtu abus elementus.
imports nejutīgs kā piem.masīvs = piem. masīvs ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
drukāt ( 'Oriģinālais masīvs:x' , masīvs )
drukāt ( 'Reālā masīva daļa:' )
drukāt ( masīvs . īsts )
drukāt ( 'Iedomātā masīva daļa:' )
drukāt ( masīvs . att )
Kā parādīts zemāk esošajā fragmentā, izvade, kurā tiek veiksmīgi izpildīta kompleksā masīva iedomātā un reālā daļa. Kur reālās daļas ir “56”, “27”, “68”, “120” un “3”. Un iedomātās daļas ir “0”.
Secinājums
Šajā rakstā mēs esam īsi apsprieduši kompleksos skaitļus un to, kā mēs varam izveidot sarežģītus masīvus, izmantojot NumPy iebūvētās funkcijas. Mēs aprakstījām vairākas funkcijas, kas ļauj mums izveidot sarežģītus masīvus, ieviešot vairākus piemērus, lai labāk izprastu.