వాక్యనిర్మాణం
సంక్లిష్ట సంఖ్యలను కలిగి ఉన్న శ్రేణిని సృష్టించడానికి వాక్యనిర్మాణం క్రింది విధంగా ఉంటుంది:
విధానం 1:
1j * np. ఏర్పాటు ( పరిమాణం )1j పైన ఇవ్వబడిన వాక్యనిర్మాణం ఊహాత్మక భాగం, అంటే మనం సంక్లిష్ట సంఖ్యల శ్రేణిని సృష్టిస్తున్నాము, ఇక్కడ np.arrang అనేది ఒక నిర్దిష్ట పరిధికి శ్రేణిని సృష్టించడానికి NumPy ద్వారా అందించబడిన ఫంక్షన్. శ్రేణి పరిమాణాన్ని సూచించే పరిమాణం, ఫంక్షన్‌కు పంపబడుతుంది.
విధానం 2:
ఉదా అమరిక ( [ Re+Re*Im , Re+Re*Im , … ] )ఈ సింటాక్స్‌లో, np.arrray అనేది శ్రేణిని సృష్టించడానికి మనల్ని ఎనేబుల్ చేసే ఫంక్షన్, కానీ మనం దానికి పరిధిని దాటలేము. మేము దానికి విలువలను “n” సార్లు పాస్ చేస్తాము. ఫంక్షన్‌లో, మేము 'Re'ని పాస్ చేసాము, ఇది వాస్తవ సంఖ్యలను 'Im'కి జోడించడం ద్వారా వాస్తవ సంఖ్య యొక్క గుణకారంలో ఊహాత్మక సంఖ్యను సూచిస్తుంది. మనం ఊహాత్మక విలువలను n సార్లు పంపవచ్చు.
ఉదాహరణ # 01:
మనకు తెలిసినట్లుగా, NumPy సంక్లిష్ట సంఖ్యలకు మద్దతు ఇస్తుంది మరియు సంక్లిష్ట సంఖ్యలను అమలు చేయడానికి మరియు మార్చడానికి అనేక రకాల పద్ధతులను అందిస్తుంది. దిగువ ఉదాహరణలో, సంక్లిష్ట సంఖ్యలను కలిగి ఉన్న శ్రేణులను సృష్టించడానికి మేము రెండు మార్గాలను అమలు చేస్తాము. NumPy ఫంక్షన్‌లను అమలు చేయడానికి, ముందుగా NumPy లైబ్రరీని npగా దిగుమతి చేద్దాం. అప్పుడు, మేము “array_a” అనే పేరు గల శ్రేణిని ప్రారంభిస్తాము, దానికి మేము సంక్లిష్ట సంఖ్యలను కలిగి ఉండే np.arange() ఫంక్షన్‌ను కేటాయిస్తాము. మరియు శ్రేణి యొక్క పరిధి '8' అవుతుంది. తదుపరి పంక్తిలో, మేము 'array_b' పేరుతో మరొక శ్రేణిని సృష్టించాము, దానికి సంక్లిష్ట విలువలను నేరుగా పంపడం ద్వారా సంక్లిష్ట సంఖ్యల శ్రేణిని మేము ఆమోదించాము. చివరికి, మేము రెండు పద్ధతులను ఉపయోగించి సృష్టించిన సంక్లిష్ట శ్రేణిని ముద్రించాము.
దిగుమతి మొద్దుబారిన వంటి ఉదా
శ్రేణి_a = 1j * np. ఏర్పాటు ( 8 )
శ్రేణి_బి = ఉదా అమరిక ( [ రెండు +1d , 3 +4j , 5 +2j , 1 +6j ] )
ముద్రణ ( 'అరంజ్() ఫంక్షన్‌ని ఉపయోగించి సంక్లిష్ట శ్రేణి' , శ్రేణి_a )
ముద్రణ ( 'np.array() ఫంక్షన్‌ని ఉపయోగించి సంక్లిష్ట శ్రేణి' , శ్రేణి_బి )
దిగువ స్నిప్పెట్‌లో చూపిన విధంగా మేము అమలు చేసిన కోడ్ యొక్క ఫలితం. మేము 0j నుండి 7j వరకు సంక్లిష్ట సంఖ్యల పరిధిని కలిగి ఉన్న రెండు శ్రేణులను సృష్టించినట్లు చూడవచ్చు. మరొకదానిలో, మేము పరిమాణం 4 యొక్క సంక్లిష్ట సంఖ్యల యాదృచ్ఛిక పరిధిని అధిగమించాము.
విధానం 3:
ఉదా క్లిష్టమైన ( Re+Re*Im )పైన ఇచ్చిన సింటాక్స్‌లో, np.complex() అనేది పైథాన్ ప్యాకేజీ NumPy ద్వారా అందించబడిన అంతర్నిర్మిత తరగతి, ఇది సంక్లిష్ట విలువలను నిల్వ చేయడానికి మాకు వీలు కల్పిస్తుంది.
ఉదాహరణ # 02:
NumPy సంక్లిష్ట శ్రేణిని సృష్టించడానికి మరొక మార్గం NumPy యొక్క కాంప్లెక్స్() తరగతిని ఉపయోగించడం. కాంప్లెక్స్ క్లాస్() సంక్లిష్ట సంఖ్యలను నిల్వ చేయడానికి ఉపయోగించబడుతుంది మరియు ఒకే కోడ్‌లో మనం చాలాసార్లు ఉపయోగించగల సంక్లిష్ట వస్తువును తిరిగి ఇస్తుంది. ఇప్పుడు కాంప్లెక్స్() క్లాస్‌ని అమలు చేస్తున్నాము, ముందుగా మన నంపీ ప్యాకేజీని దిగుమతి చేస్తాము. అప్పుడు, మేము '3+1j'లో ఉత్తీర్ణత సాధించిన కాంప్లెక్స్() క్లాస్ యొక్క ఆబ్జెక్ట్‌ను పాస్ చేయడానికి “*” అనే నక్షత్రాన్ని ఉపయోగించే సంక్లిష్ట తరగతిని ఉత్తీర్ణులైన శ్రేణిని ప్రారంభిస్తాము. అరేంజ్() ఫంక్షన్‌ని ఉపయోగించి, మేము పరిమాణం 5 యొక్క శ్రేణిని సృష్టించాము. చివరగా, మేము కాంప్లెక్స్() క్లాస్‌ని ఉపయోగించి సంక్లిష్ట శ్రేణిని సృష్టించిన కోడ్ యొక్క అవుట్‌పుట్‌ను ప్రదర్శించాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాఅమరిక = ఉదా క్లిష్టమైన ( 3 +1d ) * ఉదా. ఏర్పాటు ( 5 )
ముద్రణ ( 'np.complex() తరగతిని ఉపయోగించి సంక్లిష్ట శ్రేణి' , అమరిక )
దిగువ చిత్రంలో చూపిన విధంగా, మేము సంక్లిష్ట సంఖ్యల శ్రేణిని సృష్టించాము. కానీ చిత్రంలో మనం గమనించగలిగే మరో విషయం ఏమిటంటే, స్థిరమైన విలువ వరుసగా అమలు చేయబడదు, ఎందుకంటే మేము కాంప్లెక్స్ () తరగతికి “3+1j”ని పాస్ చేసాము, అంటే ప్రతి తదుపరి స్థిరమైన విలువలకు సంఖ్య మూడు జోడించబడుతుంది.
విధానం 4:
ఉదా వాటిని ( ఆకారం , dtype = ఏదీ లేదు , ఆర్డర్ = 'సి' , * , ఇష్టం = ఏదీ లేదు )ఈ పద్ధతిలో np.ones(), మేము NumPy శ్రేణిలోని dtype పరామితిని ఉపయోగించి సంక్లిష్ట సంఖ్యల శ్రేణిని పేర్కొంటాము. Np.ones() 1s కలిగి ఉన్న కొత్త శ్రేణిని తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. np.ones() ఫంక్షన్‌కి, మేము 'ఆకారం' అనే నాలుగు పారామితులను పాస్ చేసాము, ఇది శ్రేణి ఆకారాన్ని '2', '3' లేదా అని నిర్వచించడానికి ఉపయోగించబడుతుంది. 'dtype' అనేది డేటా రకం. మా విషయంలో మేము సంక్లిష్టమైన డేటాటైప్‌ని ఉపయోగిస్తాము. శ్రేణి ఒక డైమెన్షనల్, రెండు లేదా బహుళ డైమెన్షనల్ అని 'ఆర్డర్' నిర్వచిస్తుంది.
ఉదాహరణ # 03:
సంక్లిష్ట సంఖ్యలను ఉపయోగిస్తున్నప్పుడు ఇది ఎలా పని చేస్తుందనే దాని గురించి మంచి ఆలోచన పొందడానికి మనం ones() పద్ధతిని అమలు చేద్దాం. ఈ పద్ధతిని అమలు చేయడానికి, ముందుగా పైథాన్ అందించిన NumPy ప్యాకేజీలను దిగుమతి చేద్దాం. తరువాత, మేము np.ones() ఫంక్షన్‌ను పాస్ చేసే శ్రేణిని సృష్టిస్తాము, దానికి మేము రెండు పారామితులను పాస్ చేస్తాము. మొదటిది “4” అంటే శ్రేణి పరిమాణం 4 మరియు రెండవది “dtype” ఇది సంక్లిష్టమైనది. దీని అర్థం, మేము డేటా రకం సంక్లిష్ట సంఖ్యల శ్రేణిని సృష్టించబోతున్నాము. వన్స్() ఫంక్షన్‌ని”2” విలువతో గుణించడం అంటే మన వాస్తవ సంఖ్య “2” అవుతుంది. చివరికి, మేము ప్రింట్ స్టేట్‌మెంట్‌ని ఉపయోగించి సృష్టించిన శ్రేణిని ముద్రించాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాఅమరిక = ఉదా వాటిని ( 4 , dtype = క్లిష్టమైన ) * రెండు
ముద్రణ ( 'np.ones() ఫంక్షన్‌ని ఉపయోగించి సంక్లిష్ట శ్రేణి' , అమరిక )
దిగువ చూపిన విధంగా, మా కోడ్ యొక్క అవుట్‌పుట్ విజయవంతంగా అమలు చేయబడుతుంది, దీనిలో మేము వాస్తవ సంఖ్య 2తో 4 సంక్లిష్ట విలువలను కలిగి ఉన్న ఒక డైమెన్షనల్ శ్రేణిని కలిగి ఉన్నాము.
ఉదాహరణ # 04:
ఇప్పుడు మనం సంక్లిష్ట సంఖ్యల శ్రేణిని సృష్టించే మరొక ఉదాహరణను అమలు చేద్దాం మరియు సంక్లిష్ట సంఖ్యల యొక్క ఊహాత్మక మరియు వాస్తవ భాగాలను ముద్రిస్తాము. మేము ముందుగా NumPy లైబ్రరీని దిగుమతి చేస్తాము, ఆపై '56+0j, 27+0j, 68+0j, 49+0j, 120+0j' అనే పేరు గల 'శ్రేణి' అనే శ్రేణికి '6' సంక్లిష్ట విలువలను పాస్ చేసిన శ్రేణిని సృష్టిస్తాము. , 4+0j”. తదుపరి పంక్తిలో, మేము కేవలం శ్రేణిని ముద్రించాము. ఇప్పుడు, మేము సంక్లిష్ట శ్రేణి యొక్క ఊహాత్మక మరియు వాస్తవ విలువలను ముద్రిస్తాము.
దిగువ చూపిన రెండు ఆపరేషన్‌ల కోసం Numpy అంతర్నిర్మిత ఫంక్షన్‌ను అందిస్తుంది. ఊహాత్మక భాగాన్ని పొందే మొదటిది “array_name.imag” ఇక్కడ డాట్ ముందు ఉన్న విలువ శ్రేణి నుండి మనం ఊహాత్మక భాగాన్ని పొందవలసి ఉంటుంది. మరియు నిజమైన భాగాన్ని పొందడానికి రెండవది “array_name.real”. మా విషయంలో, శ్రేణి పేరు “శ్రేణి” కాబట్టి మేము రెండు మూలకాలను పొందడానికి ప్రింట్ స్టేట్‌మెంట్, అర్రే పేరు మరియు కీవర్డ్‌ని పాస్ చేసాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాఅమరిక = ఉదా అమరిక ( [ 56 .+ 0 . జె , 27 .+ 0 . జె , 68 .+ 0 . జె , 49 .+ 0 . జె , 120 .+ 0 . జె , 3 + 4 . జె ] )
ముద్రణ ( 'అసలు శ్రేణి:x' , అమరిక )
ముద్రణ ( 'అరే యొక్క నిజమైన భాగం:' )
ముద్రణ ( అమరిక . నిజమైన )
ముద్రణ ( 'అరే యొక్క ఊహాత్మక భాగం:' )
ముద్రణ ( అమరిక . చిత్రం )
దిగువ స్నిప్పెట్‌లో చూపిన విధంగా, సంక్లిష్ట శ్రేణి యొక్క ఊహాత్మక మరియు వాస్తవ భాగం విజయవంతంగా అమలు చేయబడిన అవుట్‌పుట్. అసలు భాగాలు “56”, “27”, “68”, “120” మరియు “3”. మరియు ఊహాత్మక భాగాలు '0లు'.
ముగింపు
ఈ కథనంలో, సంక్లిష్ట సంఖ్యలను మరియు NumPy యొక్క అంతర్నిర్మిత ఫంక్షన్‌లను ఉపయోగించి సంక్లిష్ట శ్రేణులను ఎలా సృష్టించవచ్చో మేము క్లుప్తంగా చర్చించాము. మేము బాగా అర్థం చేసుకోవడానికి బహుళ ఉదాహరణలను అమలు చేయడం ద్వారా సంక్లిష్ట శ్రేణులను సృష్టించడానికి మాకు సహాయపడే బహుళ ఫంక్షన్‌లను వివరించాము.