पायथन रिकर्सन:एक गाइड

पायथन रिकर्सन का उपयोग कैसे करें

पायथन रिकर्सन शुरुआती लोगों के लिए एक डराने वाला विषय है। आइए इस मिथक को दूर करें कि इसे परिभाषित करके रिकर्सन मुश्किल है। रिकर्सन प्रोग्रामिंग की एक विधि है जहां एक फ़ंक्शन स्वयं को कॉल करता है।

यह आसान लगता है, है ना? जब आप इसे लटका लेते हैं, तो रिकर्सन एक कठिन अवधारणा नहीं है।

इस पायथन ट्यूटोरियल में, हम रिकर्सन के बारे में बात करने जा रहे हैं और यह कैसे काम करता है। प्रोग्रामिंग की इस पद्धति के साथ आरंभ करने में आपकी सहायता के लिए हम फैक्टोरियल फ़ंक्शंस का उपयोग करके रिकर्सन के एक उदाहरण के माध्यम से चलेंगे।

पुनरावृत्ति क्या है?

रिकर्सन वह जगह है जहां आप स्वयं के संदर्भ में कुछ परिभाषित करते हैं।

एक पुनरावर्ती फ़ंक्शन स्वयं को फिर से कॉल करके समस्याओं को हल करता है। यह व्यवहार अधिकांश प्रमुख प्रोग्रामिंग भाषाओं, जैसे कि पायथन में समर्थित है। वे कंप्यूटर विज्ञान और डेटा विज्ञान का एक महत्वपूर्ण हिस्सा हैं।

रिकर्सन तब उपयोगी होता है जब किसी समस्या का समाधान छोटी समस्याओं में तोड़कर पाया जा सकता है, जो सभी एक ही सूत्र का उपयोग करते हैं। इस प्रकार की समस्याओं को अक्सर "पुनरावर्ती एल्गोरिदम" कहा जाता है। उन्हें हल करने की कुंजी नाम में है!

पुनरावर्ती बनाम पुनरावर्ती

एल्गोरिथ्म को हल करने के दो तरीके हैं:पुनरावृत्त या पुनरावर्ती।

एल्गोरिदम के पुनरावृत्त समाधान को "शक्तिशाली लेकिन बदसूरत" माना जाता है। वे काम पूरा करते हैं, लेकिन वे इसे सबसे सुंदर तरीके से नहीं करते हैं। पुनरावर्ती एल्गोरिदम को ठीक से समझने के लिए, हमें पुनरावृत्त कार्यों को देखने की आवश्यकता है।

81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।

बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।

एक पुनरावृत्त फ़ंक्शन एक ऐसा फ़ंक्शन है जो लूप का उपयोग करके किसी समस्या को हल करता है। यह लूप के अंदर कोड को तब तक निष्पादित करेगा जब तक वह लूप पूरा नहीं हो जाता। एक पुनरावर्ती फ़ंक्शन एक ऐसा फ़ंक्शन है जो किसी समस्या को छोटे भागों में विभाजित करता है और प्रत्येक भाग को स्वयं कॉल करके हल करता है।

फैक्टोरियल:पुनरावृत्त उदाहरण

फैक्टोरियल रिकर्सन और पुनरावृत्त सोच को प्रदर्शित करने का एक अच्छा तरीका है। गणित में, फैक्टोरियल एक संख्या का योग होता है और प्रत्येक संख्या को एक साथ गुणा करने से पहले।

5 का भाज्य 5 * 4 * 3 * 2 * 1 के बराबर है। 2 का भाज्य 2 * 1 के बराबर है।

भाज्य की गणना करने के लिए, हम एक पुनरावृत्तीय फलन लिख सकते हैं:

def factorial(number):
	total = 1
	for n in range(1, number + 1):
		total = total * n
	return total

यह फ़ंक्शन 1 की सीमा में सभी संख्याओं के माध्यम से पुनरावृति करने के लिए लूप के लिए उपयोग करता है और संख्या जिसे हमने प्लस 1 निर्दिष्ट किया है। प्रत्येक पुनरावृत्ति के लिए, जिस संख्या पर लूप पुनरावृत्त हो रहा है उसे कुल से गुणा किया जाता है। फैक्टोरियल खोजने के लिए हमारे फ़ंक्शन को कॉल करें:

answer = factorial(4)
print(answer)

हमारा कोड लौटाता है:24. इस समाधान पर पहुंचने के लिए, हमारा कोड चलता है:

• 1 * 1 =1
• 2 * 2 =4
• 4 * 3 =8
• 8 * 4 =24

जैसा कि आप देख सकते हैं, हमारा कोड इससे कम सभी संख्याओं के साथ 4 गुणा करता है और फिर स्वयं।

यह कोड कार्यात्मक है। एकमात्र दोष यह है कि यह उतना सुरुचिपूर्ण नहीं है जितना हो सकता है। यहीं पर पुनरावर्ती कार्य काम आते हैं।

फैक्टोरियल:रिकर्सन उदाहरण

आइए एक पुनरावर्ती फ़ंक्शन लिखें जो एक भाज्य की गणना करता है। एक नई पायथन फ़ाइल खोलें और निम्नलिखित कोड में पेस्ट करें:

def factorial(number):
	if number == 1:
		return 1
	else:
		return (number * factorial(number - 1))

यह कोड पुनरावर्ती दृष्टिकोण का उपयोग करता है। जब यह फ़ंक्शन चलाया जाता है, तो "if" कथन निष्पादित किया जाता है। यह कथन जाँचता है कि फ़ंक्शन को दी गई संख्या 1 के बराबर है या नहीं। यदि ऐसा है, तो हमारा फ़ंक्शन 1 लौटाता है। अन्यथा, हमारी संख्या के भाज्य की गणना की जाती है।

यह गणना फ़ंक्शन को दी गई संख्या को पिछली संख्या के भाज्य से गुणा करके काम करती है। इस फ़ंक्शन को बार-बार तब तक कहा जाता है जब तक कि "नंबर" 1 के बराबर न हो जाए। हर बार फ़ंक्शन को कॉल करने पर, "नंबर" का मान 1 से कम हो जाता है।

आइए अपने कोड को 4 नंबर के साथ आज़माएं:

answer = factorial(4)
print(answer)

उत्तर 24 वापस आ गया है। हमारा जवाब सही है; यह हमारे पिछले उदाहरण जैसा ही है। हमने इस समस्या का समाधान पुनरावर्ती के बजाय पुनरावर्ती रूप से पाया है।

क्या आपको अभी भी थोड़ी मदद की ज़रूरत है? आइए पुनरावर्तन के एक और उदाहरण पर चलते हैं।

फाइबोनैचि अनुक्रम के साथ पुनरावर्तन

फाइबोनैचि अनुक्रम एक गणितीय अनुक्रम है जहां प्रत्येक संख्या दो पिछली संख्याओं का योग है। यह क्रम 0, 1, 1, 2, 3, 5, 8, 13, इत्यादि से शुरू होता है।

यह क्रम अगली संख्या ज्ञात करने के लिए दो संख्याओं को जोड़ता है। यह इसे रिकर्सन के लिए आदर्श बनाता है।

एक पायथन फ़ाइल खोलें और इस कोड में पेस्ट करें:

def fibonacci(number):
	if number <= 1:
		return number
	else:
		return(fibonacci(number - 1) + fibonacci(number - 2))

यह कोड एक सूची में दो पूर्ववर्ती संख्याओं के योग की गणना करेगा, जब तक कि "संख्या" 1 से अधिक है। अन्यथा, "संख्या लौटा दी जाती है"। अब, हमारे फ़ंक्शन को कॉल करें:

executions = 5

print("Fibonacci Sequence:")
for number in range(executions):
	print(fibonacci(number))

निष्पादन चर ट्रैक करता है कि हम कितने फाइबोनैचि अनुक्रम में गणना करना चाहते हैं। हम इसका उपयोग एक लूप बनाने के लिए करते हैं जो हमारे fibonacci() . को कॉल करता है 1 की श्रेणी में प्रत्येक संख्या के लिए कार्य और "निष्पादन" का मान।

हमारे लूप के शुरू होने से पहले, हम कंसोल पर "फिबोनैचि अनुक्रम:" प्रिंट करते हैं। इस उदाहरण में, हमारा "फॉर" लूप निष्पादित होता है:

fibonacci(1)
fibonacci(2)
fibonacci(3)
fibonacci(4)
fibonacci(5)

आइए अपना कोड एक साथ चलाएं और देखें कि क्या होता है:

Fibonacci Sequence:
0
1
1
2
3

हमारा कोड फाइबोनैचि अनुक्रम में पहले पांच नंबरों की गणना करता है। हम "निष्पादन" के मान को बढ़ाकर अधिक संख्याओं की गणना कर सकते हैं।

पुनरावर्ती गहराई और आधार शर्तें

एक पुनरावर्ती फ़ंक्शन में एक आधार स्थिति होनी चाहिए। यह एक ऐसी स्थिति है जो किसी विशेष बेस केस के मिलने पर रिकर्सन को रोक देती है। आधार फ़ंक्शन के बिना, एक अनंत लूप बनाया जाएगा।

एक पुनरावर्ती फ़ंक्शन डिफ़ॉल्ट रूप से स्वयं को 1,000 से अधिक बार निष्पादित नहीं कर सकता है। एक बार जब यह सीमा समाप्त हो जाती है, तो इस तरह की त्रुटि दिखाई देती है:

RecursionError: maximum recursion depth exceeded

यहाँ हमारे फाइबोनैचि कार्यक्रम के लिए आधार शर्त है:

...
if number <= 1:
		return number
…

यह स्थिति जाँचती है कि हमारे फाइबोनैचि प्रोग्राम के अंदर "नंबर" का मान 1 के बराबर या उससे कम है। यदि ऐसा है, तो "नंबर" का मान वापस कर दिया जाता है; अन्यथा, पुनरावर्ती कार्य प्रारंभ हो जाता है।

मुझे रिकर्सन का उपयोग क्यों करना चाहिए?

पुनरावृत्ति कार्यों पर पुनरावर्तन का उपयोग करने का क्या फायदा है? तकनीकी रूप से, दोनों विधियां समान परिणाम प्राप्त कर सकती हैं। रिकर्सन का लाभ यह है कि इसे पढ़ना आसान है।

जब आप एक पुनरावर्ती फ़ंक्शन देखते हैं, तो यह स्पष्ट होता है कि किसी समस्या का उत्तर उसे छोटे भागों में विभाजित करने में है। जबकि पुनरावृत्त लूप कभी-कभी तेज हो सकते हैं, पुनरावर्ती कार्यों को आमतौर पर उनकी पठनीयता के कारण पसंद किया जाता है।

चूंकि पुनरावर्ती कार्यों को पढ़ना आसान होता है, इसलिए उन्हें बनाए रखना और डीबग करना भी आसान होता है। यह विशेष रूप से तब उपयोगी होता है जब आप जटिल एल्गोरिदम लिख रहे होते हैं जिन्हें समझना मुश्किल हो सकता है।

निष्कर्ष

एक पुनरावर्ती फ़ंक्शन एक ऐसा फ़ंक्शन है जो किसी समस्या का समाधान खोजने के लिए स्वयं को कॉल करता है।

पुनरावर्ती कार्य एक समस्या को कई भागों में विभाजित करते हैं और समस्या के एक भाग को प्रति पुनरावृत्ति हल करते हैं। पुनरावर्ती कार्यों का उपयोग आमतौर पर फाइबोनैचि अनुक्रम में फैक्टोरियल और संख्याओं की गणना के लिए किया जाता है। उनका उपयोग कई एल्गोरिदम में भी किया जाता है।

अब आप पायथन में पुनरावर्ती कार्यों के साथ काम करना शुरू करने के लिए तैयार हैं।