वाक्य - विन्यास
सम्मिश्र संख्याओं वाली एक सरणी बनाने का सिंटैक्स इस प्रकार है:
विधि 1:
1 जे * एनपी। अरेंज ( आकार )1j के ऊपर दिया गया सिंटैक्स काल्पनिक भाग है जिसका अर्थ है कि हम जटिल संख्याओं की एक सरणी बना रहे हैं, जहाँ np.arrang एक फ़ंक्शन है जो एक निर्दिष्ट सीमा के लिए एक सरणी बनाने के लिए NumPy द्वारा प्रदान किया जाता है। आकार, जो सरणी आकार को इंगित करता है, फ़ंक्शन को पास किया जाता है।
विधि 2:
जैसे सरणी ( [ पुन+पुन*Im , पुन+पुन*Im , … ] )इस सिंटैक्स में, np.array वह फ़ंक्शन है जो हमें एक सरणी बनाने में सक्षम बनाता है लेकिन हम इसे रेंज पास नहीं कर सकते। हम बस इसे 'n' बार मान देते हैं। फ़ंक्शन में, हमने 'Re' पास किया, जो वास्तविक संख्याओं को एक वास्तविक संख्या के गुणक में एक काल्पनिक संख्या 'Im' में जोड़ने का संकेत देता है। हम काल्पनिक मानों को n बार पास कर सकते हैं।
उदाहरण # 01:
जैसा कि हम जानते हैं कि NumPy जटिल संख्याओं का भी समर्थन करता है और जटिल संख्याओं को लागू करने और उनमें हेरफेर करने के लिए कई प्रकार की विधियाँ प्रदान करता है। नीचे दिए गए उदाहरण में, हम सम्मिश्र संख्याओं वाले सरणियाँ बनाने के दो तरीके लागू करेंगे। NumPy फ़ंक्शन को लागू करने के लिए, आइए पहले NumPy लाइब्रेरी को np के रूप में आयात करें। फिर, हम 'array_a' नाम की एक ऐरे को इनिशियलाइज़ करेंगे, जिसमें हम फंक्शन np.arange () असाइन करते हैं जिसमें कॉम्प्लेक्स नंबर होंगे। और सरणी की सीमा '8' होगी। अगली पंक्ति में, हमने 'array_b' नामक एक और सरणी बनाई, जिसमें हमने सीधे जटिल मानों को पास करके जटिल संख्याओं की एक सरणी पास की। अंत में, हमने दोनों विधियों का उपयोग करके बनाए गए जटिल सरणी को मुद्रित किया।
आयात Numpy जैसा जैसे
array_a = 1 जे * एनपी। अरेंज ( 8 )
array_b = जैसे सरणी ( [ दो +1d , 3 +4जे , 5 +2जे , 1 +6j ] )
प्रिंट ( 'व्यवस्था () फ़ंक्शन का उपयोग करके जटिल सरणी' , array_a )
प्रिंट ( 'np.array () फ़ंक्शन का उपयोग करके जटिल सरणी' , array_b )
जैसा कि नीचे दिए गए स्निपेट में दिखाया गया है, हमारे द्वारा निष्पादित कोड का परिणाम है। हम देख सकते हैं कि हमने दो सरणियाँ बनाई हैं जिनमें 0j से 7j तक की जटिल संख्याएँ हैं। दूसरे में, हमने आकार 4 की सम्मिश्र संख्याओं के यादृच्छिक परास को पारित किया है।
विधि 3:
जैसे जटिल ( पुन+पुन*Im )ऊपर दिए गए सिंटैक्स में, np.complex() बिल्ट-इन क्लास है जो पायथन पैकेज NumPy द्वारा प्रदान किया जाता है जो हमें जटिल मानों को स्टोर करने में सक्षम बनाता है।
उदाहरण # 02:
NumPy जटिल सरणी बनाने का दूसरा तरीका NumPy के जटिल () वर्ग का उपयोग करना है। कॉम्प्लेक्स क्लास () का उपयोग कॉम्प्लेक्स नंबरों को स्टोर करने के लिए किया जाता है और कॉम्प्लेक्स ऑब्जेक्ट को लौटाता है जिसे हम सिंगल कोड के भीतर कई बार इस्तेमाल कर सकते हैं। अब कॉम्प्लेक्स () क्लास को लागू करते हुए, हम सबसे पहले अपने Numpy पैकेज को इम्पोर्ट करेंगे। फिर, हम एक ऐरे को इनिशियलाइज़ करेंगे, जिसमें हमने एक कॉम्प्लेक्स क्लास पास की है, जो कॉम्प्लेक्स () क्लास के ऑब्जेक्ट को पास करने के लिए तारांकन '*' का उपयोग करती है, जिसमें हमने '3 + 1j' पास किया है। अरेंज () फ़ंक्शन का उपयोग करके, हमने आकार 5 की एक सरणी बनाई। अंत में, हमने केवल उस कोड का आउटपुट प्रदर्शित किया जिसमें हमने कॉम्प्लेक्स () वर्ग का उपयोग करके एक जटिल सरणी बनाई थी।
आयात Numpy जैसा जैसेसरणी = जैसे जटिल ( 3 +1d ) *जैसे अरेंज ( 5 )
प्रिंट ( 'np.complex() वर्ग का उपयोग कर जटिल सरणी' , सरणी )
जैसा कि नीचे दिए गए चित्र में दिखाया गया है, हमने सम्मिश्र संख्याओं की एक सरणी बनाई है। लेकिन एक और बात जो हम चित्र में देख सकते हैं, वह यह है कि निरंतर मान को लगातार निष्पादित नहीं किया जा रहा है क्योंकि हमने '3 + 1j' को एक जटिल () वर्ग में पारित कर दिया है, जिसका अर्थ है कि प्रत्येक अगले स्थिर मूल्यों में एक नंबर तीन जोड़ा जाएगा।
विधि 4:
जैसे लोगों ( आकार , डीटाइप = कोई भी नहीं , गण = 'सी' , * , पसंद करना = कोई भी नहीं )इस विधि में np.ones (), हम NumPy सरणी में dtype पैरामीटर का उपयोग करके जटिल संख्याओं की एक सरणी निर्दिष्ट करते हैं। Np.ones () का उपयोग एक नई सरणी को वापस करने के लिए किया जाता है जिसमें 1s होता है। फ़ंक्शन np.ones () के लिए, हमने चार पैरामीटर 'आकृति' पारित की, जिसका उपयोग सरणी के आकार को परिभाषित करने के लिए किया जाता है चाहे वह '2', '3' या अन्य हो। 'dtype' डेटा प्रकार है। हमारे मामले में हम एक जटिल डेटाटाइप का उपयोग करेंगे। 'ऑर्डर' परिभाषित करता है कि क्या सरणी एक-आयामी, दो या बहु-आयामी है।
उदाहरण # 03:
जटिल संख्याओं का उपयोग करते समय यह कैसे काम करता है, इसका बेहतर विचार प्राप्त करने के लिए आइए one() विधि को लागू करें। इस पद्धति को लागू करने के लिए, आइए पहले पायथन द्वारा प्रदान किए गए NumPy के हमारे पैकेजों को आयात करें। इसके बाद, हम एक सरणी बनाएंगे जिसमें हम np.ones () फ़ंक्शन को पास करेंगे, जिसमें हमने दो पैरामीटर पारित किए हैं। पहला '4' है जिसका अर्थ है कि सरणी का आकार 4 होगा और दूसरा 'dtype' है जो जटिल है। इसका मतलब है, हम डेटा प्रकार जटिल संख्याओं की एक सरणी बनाने जा रहे हैं। one() फंक्शन को '2' मान से गुणा करने का मतलब है कि हमारी वास्तविक संख्या '2' होगी। अंत में, हमने उस ऐरे को प्रिंट किया जिसे हमने प्रिंट स्टेटमेंट का उपयोग करके बनाया था।
आयात Numpy जैसा जैसेसरणी = जैसे लोगों ( 4 , डीटाइप = जटिल ) * दो
प्रिंट ( 'np.ones () फ़ंक्शन का उपयोग करके जटिल सरणी' , सरणी )
जैसा कि नीचे दिखाया गया है, हमारे कोड का आउटपुट सफलतापूर्वक निष्पादित होता है जिसमें हमारे पास एक-आयामी सरणी होती है जिसमें वास्तविक संख्या 2 के साथ 4 जटिल मान होते हैं।
उदाहरण # 04:
आइए अब हम एक और उदाहरण लागू करते हैं जिसमें हम सम्मिश्र संख्याओं की एक सरणी बनाएंगे और सम्मिश्र संख्याओं के काल्पनिक और वास्तविक भागों को प्रिंट करेंगे। हम पहले NumPy लाइब्रेरी को इंपोर्ट करेंगे, फिर एक ऐरे बनाएंगे, जिसमें हमने 'सरणी' नाम के एक ऐरे में '6' कॉम्प्लेक्स वैल्यू पास की हैं, जो कि '56+0j, 27+0j, 68+0j, 49+0j, 120+0j है। , 4+0j'। अगली पंक्ति में, हमने केवल ऐरे को प्रिंट किया। अब, हम सम्मिश्र सरणी के काल्पनिक और वास्तविक मानों को प्रिंट करते हैं।
Numpy नीचे दिखाए गए दोनों ऑपरेशनों के लिए एक अंतर्निहित फ़ंक्शन प्रदान करता है। काल्पनिक भाग प्राप्त करने वाला पहला 'array_name.imag' है जहां डॉट से पहले का मान वह सरणी है जिससे हमें काल्पनिक भाग प्राप्त करना है। और असली हिस्सा पाने वाला दूसरा 'array_name.real' है। हमारे मामले में, एक सरणी का नाम 'सरणी' है, इसलिए हमने दोनों तत्वों को प्राप्त करने के लिए प्रिंट स्टेटमेंट, सरणी नाम और कीवर्ड पास किया।
आयात Numpy जैसा जैसेसरणी = जैसे सरणी ( [ 56 .+ 0 . जे , 27 .+ 0 . जे , 68 .+ 0 . जे , 49 .+ 0 . जे , 120 .+ 0 . जे , 3 + 4 . जे ] )
प्रिंट ( 'मूल सरणी: x' , सरणी )
प्रिंट ( 'सरणी का असली हिस्सा:' )
प्रिंट ( सरणी . वास्तविक )
प्रिंट ( 'सरणी का काल्पनिक हिस्सा:' )
प्रिंट ( सरणी . imag के )
जैसा कि नीचे दिए गए स्निपेट में दिखाया गया है, वह आउटपुट जिसमें जटिल सरणी के काल्पनिक और वास्तविक भाग को सफलतापूर्वक निष्पादित किया जाता है। जहां वास्तविक भाग '56', '27', '68', '120' और '3' हैं। और काल्पनिक भाग '0' हैं।
निष्कर्ष
इस लेख में, हमने संक्षेप में जटिल संख्याओं पर चर्चा की है और हम NumPy के अंतर्निहित कार्यों का उपयोग करके जटिल सरणी कैसे बना सकते हैं। हमने कई कार्यों का वर्णन किया है जो हमें बेहतर समझने के लिए कई उदाहरणों को लागू करके जटिल सरणी बनाने में सक्षम बनाता है।