किसी भी फ़ंक्शन को शर्त के आधार पर सरणी में लागू करने के दो तरीके हैं। हम 'अक्ष पर लागू करें' फ़ंक्शन को लागू कर सकते हैं जो उपयोगी होता है जब हम सरणी के प्रत्येक तत्व पर एक-एक करके फ़ंक्शन लागू करते हैं, और यह एन-आयामी सरणी के लिए उपयोगी होता है। दूसरी विधि 'अक्ष के साथ लागू करें' है जो एक-आयामी सरणी पर लागू होती है।
वाक्य - विन्यास:
विधि 1: अक्ष के साथ लागू करें
सुन्न apply_along_axis ( 1डी_फ़ंक्शन , एक्सिस , आगमन , *आर्ग्स , **क्वार्ग )सिंटैक्स में, हमारे पास 'numpy.apply' फ़ंक्शन होता है जिसमें हम पांच तर्क देते हैं। पहला तर्क जो '1d_function' है वह एक-आयामी सरणी पर संचालित होता है, जिसकी आवश्यकता होती है। जबकि दूसरा तर्क, 'अक्ष', वह है जिस पर आप सरणी को टुकड़ा करना चाहते हैं और उस फ़ंक्शन को लागू करना चाहते हैं। तीसरा पैरामीटर 'गिरफ्तारी' है जो दिया गया सरणी है जिसमें हम फ़ंक्शन को लागू करना चाहते हैं। जबकि '*args' और '*kwargs' अतिरिक्त तर्क हैं जिन्हें जोड़ने की आवश्यकता नहीं है।
उदाहरण 1:
'लागू करें' विधियों की बेहतर समझ की ओर बढ़ते हुए, हम लागू विधियों के कार्य की जाँच करने के लिए एक उदाहरण प्रस्तुत करते हैं। इस उदाहरण में, हम 'apply_along_Axis' फ़ंक्शन करते हैं। आइए अपने पहले कदम पर आगे बढ़ें। हम सबसे पहले अपने NumPy पुस्तकालयों को np के रूप में शामिल करते हैं। और फिर, हम 'गिरफ्तारी' नामक एक सरणी बनाते हैं जिसमें पूर्णांक मानों के साथ 3 × 3 मैट्रिक्स होता है जो '8, 1, 7, 4, 3, 9, 5, 2, और 6' होते हैं। अगली पंक्ति में, हम 'सरणी' नामक एक चर बनाते हैं जो कि apply_along_Axis फ़ंक्शन के परिणाम को रखने के लिए जिम्मेदार है।
उस फ़ंक्शन के लिए, हम तीन तर्क देते हैं। पहला वह फ़ंक्शन है जिसे हम सरणी पर लागू करना चाहते हैं, हमारे मामले में यह सॉर्ट किया गया फ़ंक्शन है क्योंकि हम चाहते हैं कि हमारे सरणी को सॉर्ट किया जाए। फिर, हम दूसरा तर्क '1' पास करते हैं जिसका अर्थ है कि हम अपने सरणी को अक्ष = 1 के साथ टुकड़ा करना चाहते हैं। Laslty, हम उस सरणी को पास करते हैं जिसे इस मामले में क्रमबद्ध किया जाना है। कोड के अंत में, हम केवल दोनों सरणियों को प्रिंट करते हैं - मूल सरणी के साथ-साथ परिणामी सरणी - जो प्रिंट () कथन का उपयोग करके प्रदर्शित की जाती हैं।
आयात Numpy जैसा जैसे
आगमन = जैसे सरणी ( [ [ 8 , 1 , 7 ] , [ 4 , 3 , 9 ] , [ 5 , दो , 6 ] ] )
सरणी = जैसे apply_along_axis ( क्रमबद्ध , 1 , आगमन )
प्रिंट ( 'मूल सरणी है:' , आगमन )
प्रिंट ( 'क्रमबद्ध सरणी है:' , सरणी )
जैसा कि हम निम्नलिखित आउटपुट में देख सकते हैं, हमने दोनों सरणियों को प्रदर्शित किया। पहले एक में, मैट्रिक्स की प्रत्येक पंक्ति में मानों को यादृच्छिक रूप से रखा जाता है। लेकिन दूसरे में, हम क्रमबद्ध सरणी देख सकते हैं। चूंकि हमने अक्ष '1' को पारित किया है, इसने पूर्ण सरणी को सॉर्ट नहीं किया है, लेकिन इसे प्रदर्शित के अनुसार पंक्ति-वार सॉर्ट किया गया है। प्रत्येक पंक्ति को क्रमबद्ध किया जाता है। दिए गए सरणी में पहली पंक्ति '8, 1, और 7' है। जबकि क्रमबद्ध सरणी में, पहली पंक्ति '1, 7 और 8' है। इसी तरह, प्रत्येक पंक्ति को क्रमबद्ध किया जाता है।
विधि 2: अक्ष पर लागू करें
सुन्न apply_over_axes ( समारोह , एक , कुल्हाड़ियों )दिए गए सिंटैक्स में, हमारे पास numpy.apply_over_axis फ़ंक्शन है जो दिए गए अक्ष पर फ़ंक्शन को लागू करने के लिए जिम्मेदार है। Apply_over_axis फ़ंक्शन के अंदर, हम तीन तर्क देते हैं। पहला वह कार्य है जिसे किया जाना है। दूसरा एक ही सरणी है। और आखिरी वह धुरी है जिस पर हम फ़ंक्शन लागू करना चाहते हैं।
उदाहरण 2:
निम्नलिखित उदाहरण में, हम 'लागू करें' फ़ंक्शन की दूसरी विधि करते हैं जिसमें हम त्रि-आयामी सरणी के योग की गणना करते हैं। याद रखने वाली एक बात यह है कि दो सरणियों के योग का मतलब यह नहीं है कि हम पूरे सरणी की गणना करते हैं। कुछ सरणियों में, हम पंक्ति-वार योग की गणना करते हैं जिसका अर्थ है कि हम पंक्तियों को जोड़ते हैं और उनमें से एकल तत्व प्राप्त करते हैं।
आइए हमारे कोड पर आगे बढ़ें। हम पहले NumPy पैकेज इंपोर्ट करते हैं और फिर एक वेरिएबल बनाते हैं जिसमें थ्री-डायमेंशनल ऐरे होता है। हमारे मामले में, चर 'गिरफ्तारी' है। अगली पंक्ति में, हम एक और वेरिएबल बनाते हैं जो apply_over_axis फ़ंक्शन के परिणामी सरणी को रखता है। हम तीन तर्कों के साथ 'arr' चर के लिए apply_over_Axis फ़ंक्शन असाइन करते हैं। पहला तर्क np.sum के योग की गणना करने के लिए NumPy का अंतर्निहित फ़ंक्शन है। दूसरा पैरामीटर सरणी ही है। तीसरा तर्क वह अक्ष है जिस पर फ़ंक्शन लागू होता है, इस मामले में हमारे पास '[0, 2]' अक्ष है। कोड के अंत में, हम प्रिंट () स्टेटमेंट का उपयोग करके दोनों सरणियों को निष्पादित करते हैं।
आयात Numpy जैसा जैसेआगमन = जैसे सरणी ( [ [ [ 6 , 12 , दो ] , [ दो , 9 , 6 ] , [ 18 , 0 , 10 ] ] ,
[ [ 12 , 7 , 14 ] , [ दो , 17 , 18 ] , [ 0 , इक्कीस , 8 ] ] ] )
सरणी = जैसे apply_over_axes ( जैसे जोड़ , आगमन , [ 0 , दो ] )
प्रिंट ( 'मूल सरणी है:' , आगमन )
प्रिंट ( 'सरणी का योग है:' , सरणी )
जैसा कि निम्नलिखित आकृति में दिखाया गया है, हमने अपने कुछ त्रि-आयामी सरणियों की गणना apply_over_axis फ़ंक्शन का उपयोग करके की है। पहला प्रदर्शित सरणी '2, 3, 3' के आकार वाला मूल सरणी है और दूसरा पंक्तियों का योग है। पहली पंक्ति का योग '53' है, दूसरा '54' है और अंतिम '57' है।
निष्कर्ष
इस लेख में, हमने अध्ययन किया कि NumPy में लागू फ़ंक्शन का उपयोग कैसे किया जाता है और हम अक्ष के साथ या ऊपर सरणियों पर विभिन्न कार्यों को कैसे लागू कर सकते हैं। NumPy द्वारा प्रदान की गई 'लागू करें' विधियों का उपयोग करके वांछित पंक्ति या कॉलम पर किसी भी फ़ंक्शन को लागू करना आसान है। यह एक कुशल तरीका है जब हमें इसे पूरे सरणी पर लागू करने की आवश्यकता नहीं होती है। हम आशा करते हैं कि आपको यह पोस्ट लागू करने की विधि का उपयोग करने के तरीके सीखने में लाभदायक लगी होगी।