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

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

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

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

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

रिकर्सन क्या है?

रिकर्सन वह है जहां आप किसी चीज को स्वयं के संदर्भ में परिभाषित करते हैं।

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

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

इटरेटिव बनाम रिकर्सिव

एल्गोरिदम को हल करने के दो तरीके हैं: इटरेटिवली या रिकर्सिवली।

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

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

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

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

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 की रेंज में सभी संख्याओं के माध्यम से इटरेट करने के लिए एक for लूप का उपयोग करता है। प्रत्येक इटरेशन के लिए, लूप जिस संख्या पर इटरेट कर रहा है उसे कुल से गुणा किया जाता है। आइए फैक्टोरियल खोजने के लिए अपने फ़ंक्शन को कॉल करते हैं:

answer = factorial(4)
print(answer)

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

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

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

यह कोड कार्यात्मक है। एकमात्र कमी यह है कि यह उतना सुंदर नहीं है जितना हो सकता है। यहीं रिकर्सिव फ़ंक्शन्स काम आते हैं।

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

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

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

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

यह गणना फ़ंक्शन को पास की गई संख्या को पिछली संख्या के फैक्टोरियल से गुणा करके काम करती है। यह फ़ंक्शन बार-बार तब तक कॉल किया जाता है जब तक "number" 1 के बराबर नहीं हो जाता। हर बार फ़ंक्शन कॉल किया जाता है, "number" का मान 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))

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

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

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

हमारे for लूप शुरू होने से पहले, हम कंसोल पर "Fibonacci Sequence:" प्रिंट करते हैं। इस उदाहरण में, हमारा "for" लूप निष्पादित करता है:

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

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

Fibonacci Sequence:
0
1
1
2
3

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

रिकर्सन डेप्थ और बेस कंडीशन्स

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

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

RecursionError: maximum recursion depth exceeded

यहां हमारे फाइबोनैचि प्रोग्राम के लिए बेस कंडीशन है:

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

यह कंडीशन जांचती है कि हमारे फाइबोनैचि प्रोग्राम के अंदर "number" का मान 1 के बराबर या कम है या नहीं। यदि हां, तो "number" का मान लौटाया जाता है; अन्यथा, रिकर्सिव फ़ंक्शन शुरू होता है।

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

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

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

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

निष्कर्ष

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

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

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