सरल शब्दों में, हम द्वि-आयामी सरणी को किसी अन्य सरणी के भीतर एक सरणी के रूप में परिभाषित कर सकते हैं। इसका सूचकांक '0' से शुरू होता है और सरणी '-1' के आकार पर समाप्त होता है। सरणियों के भीतर सरणियों का निर्माण n बार किया जा सकता है। एक द्वि-आयामी सरणी दोनों दिशाओं में लंबवत और क्षैतिज रूप से आकार बदल सकती है।
वाक्य - विन्यास
एक सरणी घोषित करने का सिंटैक्स नीचे दिया गया है:
array_name = [ r_arr ] [ c_arr ]
array_name उस सरणी का नाम है जिसे हम बनाना चाहते हैं। जबकि, 'r_arr' सरणी की पंक्तियाँ हैं और 'c_arr' सरणी का स्तंभ है। यह वाक्यविन्यास हमें स्मृति स्थान बनाने की अनुमति देता है जहां सरणी संग्रहीत की जाएगी, या हम कह सकते हैं कि स्मृति स्थान सरणी के लिए आरक्षित किया जा सकता है।
2D सरणी घोषित करने का एक और तरीका है:
array_name = [ [ R1C1 , R1C2 , R1C3 , ... ] , [ R2C2 , R2C2 , R2C3 , ... ] , . . .. ]
उपरोक्त सिंटैक्स में, सरणी नाम उस सरणी का नाम है जहां 'R1C1', 'R2C1', ... n सरणी के तत्व हैं जहां 'R' पंक्तियों को दर्शाता है और 'c' स्तंभों को दर्शाता है। जैसा कि हम पहले वर्ग ब्रेसिज़ में देख सकते हैं, पंक्तियों की संख्या बदल रही है जबकि कॉलम समान हैं। ऐसा इसलिए है, क्योंकि सरणी के भीतर, हम कई सरणियों का उपयोग करके स्तंभों को परिभाषित करते हैं जबकि पंक्तियों को आंतरिक सरणियों के अंदर परिभाषित किया जाता है।
उदाहरण # 01: द्वि-आयामी सरणी बनाना
आइए हम द्वि-आयामी सरणी बनाने का एक व्यावहारिक उदाहरण दें और एक बेहतर विचार प्राप्त करें कि द्वि-आयामी सरणी कैसे बनाई जाती है। एक 2D सरणी बनाने के लिए, हम सबसे पहले अपनी NumPy लाइब्रेरी को आयात करेंगे जो हमें कुछ पैकेजों को लागू करने में सक्षम करेगा जो NumPy हमें सरणी बनाने के लिए प्रदान करता है। इसके बाद, हम एक वेरिएबल को इनिशियलाइज़ करेंगे जो एक सरणी बनाने के लिए द्वि-आयामी सरणी रखता है। हम np.array() फ़ंक्शन पास करेंगे जो हमें दो को किसी भी प्रकार की सरणी बनाने की अनुमति देता है चाहे वह 1D, 2D, या इसी तरह हो। उस फ़ंक्शन के लिए, हम इस सरणी के भीतर कई सरणियाँ पास करेंगे जो हमें 2-आयामी सरणी बनाने देती है।
जैसा कि हम नीचे स्क्रीनशॉट में देख सकते हैं, दूसरी पंक्ति में, हमने उस फ़ंक्शन के लिए तीन सरणियाँ पास कीं, जिसका अर्थ है कि हमारे पास तीन पंक्तियाँ हैं और उन सरणियों के भीतर, हमने प्रत्येक को 6 तत्व दिए हैं, जिसका अर्थ है कि 6 कॉलम हैं। ध्यान देने वाली एक बात यह है कि क्या हम हमेशा वर्ग कोष्ठक में तत्वों को पास करते हैं जिसका अर्थ है कि हम सरणी तत्वों को पारित कर रहे हैं और हम देख सकते हैं कि हमने एकल सरणी के भीतर कई सरणियाँ पारित की हैं।
आयात Numpy जैसा जैसे
सरणी = जैसे सरणी ( [ [ 1 , दो , 3 , 4 , 5 , 6 ] , [ 4 , 5 , 6 , 7 , 8 , 9 ] , [ 7 , 8 , 9 , 10 , ग्यारह , 12 ] ] )
प्रिंट ( सरणी )
अंत में, हमने प्रिंट स्टेटमेंट का उपयोग करके ऐरे को प्रिंट किया। जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है, हम देख सकते हैं कि सरणी प्रदर्शित होती है जिसमें 3 पंक्तियाँ और 6 कॉलम होते हैं।
उदाहरण # 02: मानों तक पहुंचना
जैसा कि हमने 2D सरणियों को बनाने की विधि का अध्ययन किया, हमारे दिमाग में एक बात जरूर आई होगी: हम 2D सरणी के तत्वों तक कैसे पहुँच सकते हैं? जबकि 2डी ऐरे के एलिमेंट को एक्सेस करना कोई बड़ी समस्या नहीं है। Numpy हमें कोड की एक सरल रेखा द्वारा सरणियों के तत्वों में हेरफेर करने में सक्षम बनाता है:
सरणी [ पंक्ति सूचकांक ] [ स्तंभ अनुक्रमणिका ]सरणी उस सरणी का नाम है जिससे हमें उस डेटा तक पहुंचना या प्राप्त करना है जहां पंक्ति अनुक्रमणिका पंक्ति का स्मृति स्थान है। और कॉलम इंडेक्स एक्सेस किए जाने वाले कॉलम का स्थान है, मान लीजिए कि हमें कॉलम के इंडेक्स '2' एलिमेंट और इंडेक्स '0' एलिमेंट को एक्सेस करना है।
जैसा कि हम नीचे दिए गए चित्र में देख सकते हैं, हमने सबसे पहले NumPy के पैकेज को एक्सेस करने के लिए NumPy लाइब्रेरी को इंपोर्ट किया। फिर, हमने चर नाम 'सरणी' घोषित किया, जिसमें 2D सरणी होती है और फिर इसे वे मान देते हैं जिन्हें हम इसमें संग्रहीत करना चाहते हैं। हमने सबसे पहले ऐरे को प्रदर्शित किया क्योंकि यह वह है जिसे हमने इनिशियलाइज़ किया है। फिर, हमने अपने प्रिंट () स्टेटमेंट में इंडेक्स के साथ एरे को पास किया, जो पूरे एरे को इंडेक्स '2' पर स्टोर करेगा। कोड की अगली पंक्ति में, हमने फिर से सरणी को दो इंडेक्स के साथ प्रिंट () स्टेटमेंट में पास किया। पहली सरणी की पंक्ति है और दूसरी सरणी का स्तंभ है जो '0' और '2' है।
आयात Numpy जैसा जैसेसरणी = जैसे सरणी ( [ [ 1 , दो , 3 , 4 , 5 , 6 ] , [ 4 , 5 , 6 , 7 , 8 , 9 ] , [ 7 , 8 , 9 , 10 , ग्यारह , 12 ] ] )
प्रिंट ( 'सरणी प्रदर्शन:' , सरणी )
प्रिंट ( 'दूसरी पंक्ति प्रदर्शित करें:' , सरणी [ दो ] )
प्रिंट ( 'पहली पंक्ति और 2 स्तंभ तत्व प्रदर्शित करें:' , सरणी [ 0 ] [ दो ] )
कोड कंपाइलर चलाते समय निम्न आउटपुट लौटाया जाता है, जो सरणी को प्रिंट करता है। फिर, कोड के अनुसार दूसरी पंक्ति। अंत में, कंपाइलर उस तत्व को लौटाता है जो पंक्तियों के लिए इंडेक्स '0' और कॉलम के लिए इंडेक्स '2' पर संग्रहीत होता है।
उदाहरण #03: मूल्यों को अद्यतन करना
हम पहले से ही इस बात पर चर्चा कर चुके हैं कि हम 2D सरणी के भीतर डेटा या तत्वों को कैसे बना या एक्सेस कर सकते हैं, लेकिन जब हमें सरणी के तत्वों को बदलना होता है, तो हम केवल उस विधि का उपयोग कर सकते हैं जो NumPy पैकेज द्वारा प्रदान की जाती है जो हमें अनुमति देती है एक सरणी के भीतर वांछित मान को अद्यतन करने के लिए।
मूल्य को अद्यतन करने के लिए, हम उपयोग करते हैं:
सरणी [ पंक्ति_सूचकांक ] [ कॉलम_इंडेक्स ] = [ मूल्यों ]उपरोक्त वाक्य रचना में, सरणी सरणी का नाम है। पंक्ति अनुक्रमणिका वह स्थान या स्थान है जिसे हम संपादित करेंगे। स्तंभ अनुक्रमणिका उस स्तंभ का स्थान है जिस पर मान अद्यतन किया जाता है, जहां मान वह होता है जिसे वांछित अनुक्रमणिका में जोड़ा जाना चाहिए।
जैसा कि हम देख सकते हैं, हम सबसे पहले अपनी NumPy लाइब्रेरी को इम्पोर्ट करते हैं। और फिर आकार 3×6 की एक सरणी घोषित की और इसके पूर्णांक मानों को पारित किया। फिर, हमने मान '21' को सरणी में पास कर दिया, जिसका अर्थ है कि हम '21' मान को एक पंक्ति के '0' और एक कॉलम के '2' पर संग्रहीत करना चाहते हैं, जिसका अर्थ है कि हम इसे सूचकांक में संग्रहीत करना चाहते हैं पहली पंक्ति और 3 . की तृतीय सरणी का स्तंभ। फिर दोनों सरणियों को प्रिंट करें, मूल एक और उस तत्व को भी जिसे हमने सरणी में संग्रहीत किया है।
आयात Numpy जैसा जैसेसरणी = जैसे सरणी ( [ [ 1 , दो , 3 , 4 , 5 , 6 ] , [ 4 , 5 , 6 , 7 , 8 , 9 ] , [ 7 , 8 , 9 , 10 , ग्यारह , 12 ] ] )
सरणी [ 0 ] [ दो ] = इक्कीस
प्रिंट ( 'सरणी प्रदर्शन:' , सरणी )
प्रिंट ( 'पहली पंक्ति और 2 स्तंभ तत्व प्रदर्शित करें:' , सरणी [ 0 ] [ दो ] )
जैसा कि नीचे दिखाया गया है, NumPy पैकेज द्वारा प्रदान की गई कोड की एक साधारण पंक्ति को जोड़कर मान को सफलतापूर्वक सरणी में अपडेट किया जाता है।
निष्कर्ष
इस लेख में, हमने द्वि-आयामी सरणियों को बनाने के विभिन्न तरीकों के बारे में बताया और कैसे हम NumPy के अंतर्निहित कार्यों का उपयोग करके उनमें हेरफेर कर सकते हैं। हमने चर्चा की कि हम सरणी के भीतर तत्वों तक कैसे पहुंच सकते हैं और उन्हें अपडेट कर सकते हैं। Numpy हमें कोड की एक पंक्ति द्वारा बहु-आयामी सरणियों को बनाने और उनमें हेरफेर करने में सक्षम बनाता है। अजगर सूचियों की तुलना में नुकीले सरणियाँ स्पष्ट और अधिक प्रभावी हैं।