सरल शब्दों में, पुनरावृत्ति एक समस्या है जो स्वयं कॉल करने के द्वारा समस्या को हल करने का एक तरीका है, शब्द ' पुनरावर्ती 'लैटिन क्रिया से उत्पन्न' पीछे हटना ”, जिसका अर्थ किसी चीज को फिर से बनाना है। यह वही है जो पुनरावर्ती कार्य करता है, यह बार-बार एक ही चीज़ को फिर से करता है, अर्थात यह खुद को याद करता है। इस लेख में, हम अजगर में पुनरावृत्ति के बारे में जानेंगे। इस ब्लॉग में निम्नलिखित विषय शामिल हैं:
- पायथन में पुनरावृत्ति क्या है?
- समाप्ति की स्थिति
- पायथन की पुनरावृत्ति सीमा
- पुनर्संरचना के साथ चपटी सूची
- पुनर्मुद्रण के लाभ
- पुनरावृत्ति के नुकसान
पायथन में पुनरावृत्ति क्या है?
रिकर्सन अपने आप में कुछ निर्धारित करने की प्रक्रिया है। हम जानते हैं कि पायथन में, कोई भी फ़ंक्शन किसी अन्य फ़ंक्शन को कॉल कर सकता है, एक फ़ंक्शन स्वयं भी कॉल कर सकता है। इस प्रकार के फ़ंक्शंस जो निश्चित स्थिति पूरी होने तक खुद को कॉल करते हैं, को पुनरावर्ती कार्यों के रूप में कहा जाता है।
यह देखने के लिए कुछ उदाहरण दें कि यह कैसे काम करता है, यदि आपको एक सकारात्मक पूर्णांक दिया जाता है, तो तथ्य यह होगा कि
- n! = n * (n-1) * (n-2) इत्यादि।
- २! = 2 * (2-1)
- एक! = 1
- ०! = 0
- ४! = ४ * ३!
- ३! = ३ * २!
- २! = २ * १!
उपरोक्त मूल्यों को प्रतिस्थापित करने के परिणामस्वरूप निम्नलिखित अभिव्यक्ति होगी
- ४! = 4 * 3 * 2 * 1
हमें एक फंक्शन को परिभाषित करने की अनुमति देता है जो तथ्य (n) कहता है जो सकारात्मक पूर्णांक या 0 को इसके पैरामीटर के रूप में लेता है और nth factorial को लौटाता है, हम पुनरावृत्ति का उपयोग करके कैसे कर सकते हैं?
आइए देखें, ऐसा करने के लिए पुनरावर्तन का उपयोग करते हुए हमें निम्नलिखित समीकरण की जांच करने की आवश्यकता है
n! = n। (n-1)। (n-2) & hellip3.2.1
n! = एन! (एन -1)! # हम इस पंक्ति के अनुसार उपरोक्त कथन को फिर से लिख सकते हैं
अब यहाँ अगर हम पैरामीटर के रूप में 2 पास करते हैं तो हमें मिलेगा:
२! = २.१! = २
ऑपरेटर की शक्ति के लिए जावा
इसी तरह, यदि हम 1 पास करते हैं तो हमें मिलेगा:
एक! = 1.0! = 1
लेकिन अगर हम 0 पास करते हैं, तो यह टूट जाता है
०! = 0! (- 1)! और यहाँ -1 के लिए भाज्य को परिभाषित नहीं किया गया है, इसलिए यह केवल मूल्यों के लिए काम करता है> 0
इसलिए हमें दो मामले लिखने होंगे
1. n! = एन! (एन -1)! अगर n> = 1
२. 0 यदि n = ०
यह सभी सकारात्मक पूर्णांकों और 0 के लिए एक पूर्ण समाधान है।
समाप्ति की स्थिति
एक पुनरावर्ती कार्य को समाप्त करने के लिए एक महत्वपूर्ण शर्त को पूरा करना पड़ता है। एक ऐसी स्थिति की ओर बढ़ रहा है जहाँ समस्या को आगे की पुनरावृत्ति के बिना हल किया जा सकता है, एक पुनरावर्ती कार्य समाप्त हो जाएगा, समस्या को छोटे उप-चरणों में कम से कम करेगा। यदि कॉल में समाप्ति की स्थिति पूरी नहीं होती है, तो एक अनंत लूप में एक पुनरावृत्ति समाप्त हो सकती है।
तथ्य की स्थिति:
- n = n * (n-1) का भाज्य जब तक n 1 से अधिक है।
- 1 यदि एन = 0
हम अजगर कोड में उपर्युक्त तथ्यात्मक स्थितियों को परिवर्तित करेंगे:
def fact (n): अगर n == 1: रिटर्न n और: रिटर्न n * fact (n-1)
आइए एक उदाहरण लेते हैं, कहते हैं कि हम 4 का तथ्यात्मक पता लगाना चाहते हैं:
fact (4) #this 4 * fact (3) और इतने पर n == 1 तक वापस आ जाएगा।
आउटपुट: २४
इसकी सरलता और स्पष्टता के कारण इसका उपयोग अक्सर पुनरावृत्ति के लिए एक उदाहरण के रूप में किया जाता है। प्रत्येक चरण में एक समस्या के छोटे उदाहरणों को हल करना, जिसे कंप्यूटर विज्ञान में पुनरावृत्ति कहा जाता है।
पायथन की पुनरावृत्ति सीमा
कुछ भाषाओं में, आप एक अनंत पुनरावर्ती लूप बना सकते हैं लेकिन, पायथन में, एक पुनरावर्ती सीमा है। सीमा की जाँच करने के लिए sys मॉड्यूल से निम्न फ़ंक्शन चलाएँ। जो अजगर के लिए निर्धारित पुनरावृत्ति की सीमा देगा।
यदि एसक्यूएल प्रश्नों में कथन
आयात sys sys.getrecursionlimit ()
आउटपुट: 1000
आप अपनी आवश्यकता के अनुसार, sys मॉड्यूल के कार्यपत्रक कर्मचारी () का उपयोग करके सीमा को बदल सकते हैं, अब एक फ़ंक्शन बनाते हैं जो स्वयं को पुनरावर्ती रूप से कॉल कर रहा है जब तक कि यह सीमा से अधिक नहीं हो जाता है और क्या होता है इसकी जाँच करता है:
def पुनरावर्ती (): पुनरावर्ती () यदि __name__ == '__main__': पुनरावर्ती ()
यदि आप उपरोक्त कोड चलाते हैं, तो आपको एक रनटाइम अपवाद मिलेगा: RuntimeError: अधिकतम पुनरावर्ती गहराई पार हो गई है। पायथन आपको एक फ़ंक्शन बनाने से रोकता है जो कभी न खत्म होने वाले पुनरावर्ती लूप में समाप्त होता है।
पुनर्संरचना के साथ चपटी सूची
अन्य चीजें जो आप पुनरावर्तन का उपयोग करके कर सकते हैं, तथ्यात्मक को छोड़कर, मान लें कि आप किसी सूची से एकल बनाना चाहते हैं जो नेस्टेड है, यह नीचे दिए गए कोड का उपयोग करके किया जा सकता है:
def flatten (a_list, flat_list = none): अगर flat_list कोई नहीं है: flat_list = [] में आइटम के लिए a_list: यदि आइंस्टीन (आइटम, सूची): flatten (आइटम, flat_list)) तो flat_list.append (आइटम) लौटते हैं तो __name__ == '__main__': nested = [1,2,3, [4,5], 6] x = flatten (नेस्टेड) प्रिंट (x)
आउटपुट: [1,2,3,4,5,6]
उपरोक्त कोड को चलाने से पूर्णांक सूची के बजाय एकल सूची में परिणाम होगा, जिसका उपयोग हमने इनपुट के रूप में किया था। आप अन्य तरीकों का उपयोग करके भी ऐसा ही कर सकते हैं, पायथन ने कुछ को इटर्टुलसैचिन () कहा है, आप फ़ंक्शन श्रृंखला बनाने के लिए उपयोग किए गए कोड की जांच कर सकते हैं () यह एक अलग दृष्टिकोण है जैसा हमने किया था।
पुनर्मुद्रण के लाभ
एक पुनरावर्ती कार्य में कोड साफ और सुरुचिपूर्ण है।
एक समग्र कार्य पुनरावृत्ति का उपयोग करके सरल उप-समस्याओं में टूट सकता है।
कुछ नेस्टेड पुनरावृति का उपयोग करने की तुलना में पुनरावृत्ति के साथ अनुक्रम उत्पन्न करना आसान है।
पुनरावृत्ति के नुकसान
पुनरावर्ती कार्य के पीछे तर्क कभी-कभी कठिन हो सकता है।
पुनरावर्ती कॉल महंगे (अक्षम) हैं क्योंकि वे बहुत अधिक मेमोरी और समय लेते हैं।
पुनरावर्ती कार्यों को डीबग करना कठिन है।
इस लेख में हमने देखा कि पुनरावृत्ति क्या है और हम समस्या कथन से पुनरावर्ती कार्यों को कैसे विकसित कर सकते हैं, गणितीय रूप से समस्या कथन को कैसे परिभाषित किया जा सकता है। हमने तथ्यात्मक की एक समस्या को हल किया और उन तथ्यों को खोजने के लिए आवश्यक शर्तों का पता लगाया, जिनसे हम उस स्थितियों को अजगर कोड में बदलने में सक्षम थे, जो आपको यह समझने की समझ देता है कि पुनरावृत्ति कैसे काम करती है। मुझे लगता है कि यह साफ है कि पायथन में डेवलपर्स को खराब निर्माण किए गए पुनरावर्ती कार्यों को बनाने से रोकने के लिए पुनरावृत्ति की एक अंतर्निहित सीमा है। नोटिस करने के लिए एक महत्वपूर्ण बात यह है कि पुनरावृत्ति डिबग करना कठिन है क्योंकि फ़ंक्शन खुद को कॉल करता है।