Syntax
Ang syntax para sa paglikha ng isang array na naglalaman ng mga kumplikadong numero ay ang mga sumusunod:
Paraan 1:
1j * np. arange ( laki )Ang syntax na ibinigay sa itaas 1j ay ang haka-haka na bahagi na nangangahulugang gumagawa tayo ng hanay ng mga kumplikadong numero, kung saan ang np.arrang ay ang function na ibinigay ng NumPy upang lumikha ng array sa isang tinukoy na hanay. Ang laki, na nagpapahiwatig ng laki ng array, ay ipinapasa sa function.
Paraan 2:
hal. array ( [ Re+Re*Im , Re+Re*Im , … ] )Sa syntax na ito, ang np.arrray ay ang function na nagbibigay-daan sa amin na lumikha ng array ngunit hindi namin maipasa ang range dito. Nagpapasa lang kami ng mga halaga dito ng 'n' beses. Sa function, ipinasa namin ang 'Re' na nagpapahiwatig ng mga tunay na numero na nagdaragdag sa kanila sa 'Im' na isang haka-haka na numero sa maramihang ng isang tunay na numero. Maaari naming ipasa ang mga haka-haka na halaga sa n beses.
Halimbawa # 01:
Tulad ng alam natin, sinusuportahan din ng NumPy ang mga kumplikadong numero at nagbibigay ng maraming uri ng mga pamamaraan para ipatupad at manipulahin ang mga kumplikadong numero. Sa halimbawa sa ibaba, ipapatupad namin ang dalawang paraan upang lumikha ng mga array na naglalaman ng mga kumplikadong numero. Upang ipatupad ang mga function ng NumPy, i-import muna natin ang NumPy library bilang np. Pagkatapos, magsisimula kami ng array na pinangalanang 'array_a' kung saan itatalaga namin ang function np.arange() na maglalaman ng mga kumplikadong numero. At ang hanay ng array ay magiging '8'. Sa susunod na linya, lumikha kami ng isa pang array na pinangalanang 'array_b' kung saan ipinasa namin ang isang hanay ng mga kumplikadong numero sa pamamagitan ng pagpasa ng mga kumplikadong halaga nang direkta dito. Sa huli, nai-print namin ang kumplikadong array na aming nilikha gamit ang parehong mga pamamaraan.
angkat numpy bilang hal.
array_a = 1j * np. arange ( 8 )
array_b = hal. array ( [ dalawa +1d , 3 +4j , 5 +2j , 1 +6j ] )
print ( 'complex array gamit ang arange() function' , array_a )
print ( 'complex array gamit ang np.array() function' , array_b )
Tulad ng ipinapakita sa snippet sa ibaba ay ang resulta ng code na aming naisakatuparan. Makikita natin na nakagawa tayo ng dalawang array na may hanay ng mga kumplikadong numero mula 0j hanggang 7j. Sa isa pa, naipasa namin ang random na hanay ng mga kumplikadong numero na may sukat na 4.
Paraan 3:
hal. kumplikado ( Re+Re*Im )Sa syntax na ibinigay sa itaas, ang np.complex() ay ang built-in na klase na ibinigay ng Python package NumPy na nagbibigay-daan sa amin na mag-imbak ng mga kumplikadong halaga.
Halimbawa # 02:
Ang isa pang paraan upang lumikha ng NumPy complex array ay ang paggamit ng complex() class ng NumPy. Ang kumplikadong klase() ay ginagamit upang mag-imbak ng mga kumplikadong numero at ibalik ang kumplikadong bagay na maaari nating gamitin nang maraming beses sa loob ng iisang code. Ngayon, ipinapatupad ang complex() na klase, i-import muna namin ang aming Numpy package. Pagkatapos, magsisimula kami ng isang array kung saan naipasa namin ang isang kumplikadong klase na gumagamit ng asterisk na '*' upang ipasa ang isang object ng complex() na klase kung saan naipasa namin ang '3+1j'. Gamit ang arrange() function, gumawa kami ng array na may sukat na 5. Sa wakas, ipinakita lang namin ang output ng code kung saan gumawa kami ng complex array gamit ang complex() class.
angkat numpy bilang hal.array = hal. kumplikado ( 3 +1d ) *hal. arange ( 5 )
print ( 'complex array gamit ang np.complex() class' , array )
Tulad ng ipinapakita sa figure sa ibaba, lumikha kami ng isang hanay ng mga kumplikadong numero. Ngunit ang isa pang bagay na mapapansin natin sa figure ay ang pare-parehong halaga ay hindi sunud-sunod na isinasagawa dahil naipasa natin ang '3+1j' sa isang complex() na klase na nangangahulugang isang numerong tatlo ang idadagdag sa bawat susunod na pare-parehong halaga.
Paraan 4:
hal. mga ( Hugis , dtype = wala , utos = 'C' , * , gusto = wala )Sa pamamaraang ito np.ones(), tinukoy namin ang isang hanay ng mga kumplikadong numero gamit ang dtype na parameter sa array ng NumPy. Np.ones() ay ginagamit upang ibalik ang isang bagong array na naglalaman ng 1s. Sa function na np.ones(), ipinasa namin ang apat na parameter na 'hugis', na ginagamit upang tukuyin ang hugis ng array kung ito ay '2', '3' o iba pa. Ang 'dtype' ay ang uri ng data. Sa aming kaso, gagamit kami ng isang kumplikadong uri ng data. Tinutukoy ng “order” kung ang array ay one-dimensional, two, o multi-dimensional.
Halimbawa # 03:
Ipatupad natin ang pamamaraang ones() para magkaroon ng mas magandang ideya kung paano ito gumagana habang gumagamit ng mga kumplikadong numero. Upang ipatupad ang paraang ito, i-import muna natin ang ating mga pakete ng NumPy na ibinigay ng Python. Susunod, gagawa kami ng array kung saan ipapasa namin ang np.ones() function kung saan naipasa namin ang dalawang parameter. Ang una ay '4' na nangangahulugang ang laki ng array ay magiging 4 at ang pangalawa ay 'dtype' na kumplikado. Ibig sabihin, gagawa tayo ng isang hanay ng mga kumplikadong numero ng uri ng data. Ang pag-multiply ng ones() function na may value na”2” ay nangangahulugan na ang ating tunay na numero ay magiging “2”. Sa huli, na-print namin ang array na aming ginawa gamit ang print statement.
angkat numpy bilang hal.array = hal. mga ( 4 , dtype = kumplikado ) * dalawa
print ( 'complex array gamit ang np.ones() function' , array )
Tulad ng ipinapakita sa ibaba, ang output ng aming code ay matagumpay na naisakatuparan kung saan mayroon kaming one-dimensional array na naglalaman ng 4 na kumplikadong mga halaga na may tunay na numero 2.
Halimbawa # 04:
Ipatupad natin ngayon ang isa pang halimbawa kung saan gagawa tayo ng hanay ng mga kumplikadong numero at ipi-print ang mga haka-haka at tunay na bahagi ng kumplikadong mga numero. I-import muna namin ang NumPy library, pagkatapos ay gagawa kami ng array kung saan ipinasa namin ang '6' complex values sa isang array na pinangalanang 'array' na '56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j”. Sa susunod na linya, na-print lang namin ang array. Ngayon, nag-print kami ng mga haka-haka at totoong halaga ng kumplikadong array.
Nagbibigay ang Numpy ng built-in na function para sa parehong mga operasyon na ipinapakita sa ibaba. Ang unang nakakuha ng haka-haka na bahagi ay ang 'array_name.imag' kung saan ang halaga bago ang tuldok ay ang array kung saan kailangan nating makuha ang haka-haka na bahagi. At ang pangalawa upang makuha ang totoong bahagi ay 'array_name.real'. Sa aming kaso, ang pangalan ng isang array ay 'array' kaya ipinasa namin ang print statement, ang array name, at ang keyword upang makuha ang parehong mga elemento.
angkat numpy bilang hal.array = hal. array ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
print ( 'Orihinal na array:x' , array )
print ( 'Tunay na bahagi ng array:' )
print ( array . totoo )
print ( 'Imaginary na bahagi ng array:' )
print ( array . imag )
Tulad ng ipinapakita sa snippet sa ibaba, ang output kung saan ang haka-haka at ang tunay na bahagi ng complex array ay matagumpay na naisakatuparan. Kung saan ang mga tunay na bahagi ay '56', '27', '68', '120', at '3'. At ang mga haka-haka na bahagi ay '0's'.
Konklusyon
Sa artikulong ito, panandalian naming tinalakay ang mga kumplikadong numero at kung paano kami makakagawa ng mga kumplikadong array gamit ang mga built-in na function ng NumPy. Inilarawan namin ang maraming mga function na nagbibigay-daan sa amin upang lumikha ng mga kumplikadong array sa pamamagitan ng pagpapatupad ng maraming mga halimbawa upang mas maunawaan.