अगर आप Python सीख रहे हैं तो Recursion एक ऐसा concept है जो आपको जरूर समझना चाहिए। Recursion programming का एक महत्वपूर्ण और शक्तिशाली तरीका है जो complex problems को simple बनाता है। इस blog post में हम Python Recursion को शुरू से लेकर advanced level तक, बिल्कुल आसान भाषा में, real coding examples के साथ समझेंगे। अगर आपने अभी तक Python Functions के बारे में नहीं पढ़ा है, तो पहले वो article पढ़ना बेहतर रहेगा क्योंकि Recursion समझने के लिए Functions की basic जानकारी होना जरूरी है।

नीचे दी गई video में भी हमने इसी topic को visually explain किया है:

इस Article में आप क्या सीखेंगे?

• Recursion क्या है और Recursive Function कैसे काम करता है
• Function खुद को कैसे call करता है
• Base Case और Recursive Case का मतलब
• Recursion का पूरा Flow (step-by-step)
• Counting का Practical Example
• Factorial using Recursion (पूरी coding के साथ)
• Recursion कब stop होता है और Infinite Recursion की problem
• VS Code में Real Coding Examples
• एक Final Coding Challenge जो आप खुद solve कर सकते हैं

Recursion क्या है? (What is Recursion?)

Recursion एक programming technique है जहाँ एक function अपने आप को call करता है। जब कोई function खुद को call करता है, तो उसे recursive function कहते हैं। Recursion का use करके हम बड़ी problems को छोटे-छोटे parts में divide करके solve कर सकते हैं। यह concept Data Structures जैसे Trees और Graphs में बहुत ज्यादा इस्तेमाल होता है, इसलिए अगर आप coding interviews की तैयारी कर रहे हैं तो Recursion पर पकड़ मजबूत होना बेहद जरूरी है।

सरल शब्दों में - Recursion = Function calling itself

Recursion का Real-Life Example

आइए एक real-life example से समझते हैं। मान लीजिए आप किसी folder को खोलते हैं और उसमें और भी folders हैं। हर folder को check करने के लिए आप वही process repeat करते हैं - यह recursion है! ठीक इसी तरह अगर आप आमने-सामने रखे दो mirrors में देखें, तो image बार-बार खुद को repeat करती है - यह भी recursion जैसा ही behaviour है।

Recursive Function क्या है?

Recursive Function वह function होता है जिसकी definition के अंदर ही उसी function को call किया जाता है। जब भी हम कोई ऐसा function लिखते हैं जो अपने आप को call करे, तो उसे हम Recursive Function कहते हैं। सामान्य function की तरह ही यह भी parameters accept करता है और value return करता है, बस फर्क सिर्फ इतना है कि यह अपने problem को solve करने के लिए खुद को दोबारा call करता है।

Function खुद को कैसे Call करता है?

जब कोई function अपने body के अंदर अपने ही नाम को call करता है, तो Python उस function की एक नई copy को stack (जिसे Call Stack कहते हैं) में add कर देता है। हर बार जब function खुद को call करता है, एक नया function call stack पर push हो जाता है। जैसे ही base case पूरा होता है, यह stack ऊपर से नीचे की तरफ unwind होना शुरू होता है और हर call अपना result वापस पिछले call को भेज देता है।

Recursion के जरूरी Components

1. Base Case (आधार स्थिति)

Base Case वह condition है जहाँ recursion रुक जाता है। बिना base case के आपका function infinite loop में चला जाएगा। Base case बहुत महत्वपूर्ण है क्योंकि यह recursion को control करता है। हर recursive function में कम से कम एक base case होना चाहिए, वरना program crash हो जाएगा (RecursionError)।

2. Recursive Case

Recursive Case वह part है जहाँ function अपने आप को call करता है, लेकिन छोटे input के साथ। हर recursive call के साथ input value धीरे-धीरे base case के करीब पहुंचती है, तभी जाकर recursion सही तरीके से खत्म होता है।

Recursion का Flow कैसे काम करता है?

Recursion का flow समझने के लिए इसे दो phases में बांटा जा सकता है:

• Winding Phase: Function बार-बार खुद को call करता है और base case की तरफ बढ़ता है।
• Unwinding Phase: Base case पूरा होते ही, हर call अपना result पिछले call को return करना शुरू करता है, यानी stack नीचे से ऊपर unwind होता है।

यही winding और unwinding process मिलकर पूरा recursion flow बनाता है, और यही चीज़ recursion को loop से अलग बनाती है।

Counting का Practical Example

सबसे पहले recursion समझने के लिए एक बहुत आसान example लेते हैं - 1 से n तक counting करना।

def count_numbers(n):
    # Base Case
    if n == 0:
        return
    
    # पहले छोटी value print करो
    count_numbers(n - 1)
    
    # फिर current value print करो
    print(n)

# Function को call करते हैं
count_numbers(5)
# Output:
# 1
# 2
# 3
# 4
# 5

इस example में हर call पहले खुद को छोटी value के साथ call करता है, और जब base case (n == 0) आ जाता है, तभी print होना शुरू होता है। इससे आप clearly देख सकते हैं कि function calls पहले winding होते हैं, फिर unwind होते समय काम करते हैं।

Python में Recursion - Practical Examples

Example: Factorial (भाज्य) निकालना

अब एक थोड़ा और उपयोगी example देखते हैं - factorial calculate करना। Factorial का मतलब है n! = n × (n-1) × (n-2) × ... × 1

def factorial(n):
    # Base Case
    if n == 0 or n == 1:
        return 1
    
    # Recursive Case
    else:
        return n * factorial(n - 1)

# Function को call करते हैं
print(factorial(5))  # Output: 120

यह कैसे काम करता है:

• factorial(5) = 5 × factorial(4)
• factorial(4) = 4 × factorial(3)
• factorial(3) = 3 × factorial(2)
• factorial(2) = 2 × factorial(1)
• factorial(1) = 1 (Base Case - यहाँ recursion रुक जाता है)

फिर सब values multiply होती हैं: 5 × 4 × 3 × 2 × 1 = 120

अगर आप Python के basics जैसे Operators और Data Types में और गहराई से जाना चाहते हैं, तो हमारा Python Operators in Hindi वाला article भी जरूर पढ़ें।

Recursion कब Stop होता है?

Recursion तभी रुकता है जब function का Base Case satisfy हो जाता है। जैसे ही condition true होती है, function कोई value return करता है, बिना खुद को दोबारा call किए। अगर base case कभी true ही न हो, तो function हमेशा खुद को call करता रहेगा।

Infinite Recursion की Basic Problem

अगर किसी recursive function में base case defined नहीं है, या base case कभी true नहीं होता, तो function infinite बार खुद को call करता रहेगा। इसे Infinite Recursion कहते हैं। इससे Python का memory stack भर जाता है और program एक error देता है:

RecursionError: maximum recursion depth exceeded

गलत Example (Infinite Recursion):

def wrong_function(n):
    print(n)
    return wrong_function(n - 1)   # ❌ कोई Base Case नहीं है

wrong_function(5)  # यह कभी नहीं रुकेगा और error देगा

इसलिए हमेशा ध्यान रखें कि हर recursive function में एक valid base case जरूर हो, और recursive call हर बार उस base case के करीब पहुंचे। अगर आप ऐसे errors debug करने के तरीके सीखना चाहते हैं, तो हमारा Python Tutorial Hub देख सकते हैं, जिसमें Exception Handling भी cover किया गया है।

VS Code में Real Coding Examples

अब बात करते हैं कि VS Code में recursion को practically कैसे test करें। सबसे पहले VS Code में एक नई Python file बनाएं, जैसे recursion_demo.py, और नीचे दिया गया code paste करें:

# recursion_demo.py

def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)

def count_numbers(n):
    if n == 0:
        return
    count_numbers(n - 1)
    print(n)

def sum_of_digits(n):
    if n == 0:
        return 0
    return n % 10 + sum_of_digits(n // 10)

if __name__ == "__main__":
    print("Factorial of 5:", factorial(5))
    print("Counting from 1 to 5:")
    count_numbers(5)
    print("Sum of digits of 12345:", sum_of_digits(12345))

इस file को VS Code के integrated terminal में python recursion_demo.py command से run करें। आप debugger का इस्तेमाल करके हर recursive call पर breakpoint लगा सकते हैं और देख सकते हैं कि Call Stack में क्या हो रहा है - यह recursion को visually समझने का सबसे बेहतर तरीका है। Python setup के बारे में पूरी जानकारी के लिए हमारा Python Installation Guide देख सकते हैं।

Final Coding Challenge 🏆

अब जब आपने Recursion अच्छे से समझ लिया है, तो खुद से एक challenge solve करके देखें:

Challenge: एक recursive function fibonacci(n) लिखिए जो n-वां Fibonacci number return करे। (Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13...)

Hint: इसमें base case के लिए दो conditions होंगी - n == 0 और n == 1। बाकी सभी values के लिए function को दो बार खुद को call करना होगा।

# अपना solution यहाँ try करें
def fibonacci(n):
    # यहाँ अपना code लिखें
    pass

print(fibonacci(6))  # Expected Output: 8

अगर आप अटक जाएं, तो हमारे Top 100 Python Interview Questions section में और भी practice problems मिल जाएंगे।

Recursion vs Loop - कौन सा Better है?

अक्सर beginners सोचते हैं कि Recursion हमेशा Loop से बेहतर होता है, जबकि ऐसा नहीं है। Loop आमतौर पर memory efficient होता है क्योंकि उसमें बार-बार function call stack पर नहीं जाता, जबकि Recursion code को ज्यादा readable और clean बनाता है, खासकर tree traversal, backtracking, और divide-and-conquer जैसी problems में। इस topic पर हमारे Python For Loop और Python While Loop वाले articles भी जरूर पढ़ें।

निष्कर्ष (Conclusion)

इस article में हमने Python Recursion को शुरू से लेकर advanced level तक cover किया - Recursion क्या है, Recursive Function कैसे काम करता है, Base Case और Recursive Case का महत्व, Counting और Factorial जैसे practical examples, Infinite Recursion की problem, और VS Code में real coding practice। Recursion एक ऐसा concept है जिसे practice करके ही अच्छे से समझा जा सकता है, इसलिए ऊपर दिए गए examples को खुद VS Code में run करके देखें और Final Challenge को solve करने की कोशिश जरूर करें।

Related Articles

• Python Function में pass क्यों लगाते हैं?
• Python For Loop in Hindi - Complete Guide
• Python While Loop in Hindi - Complete Course
• Global vs Local Variables in Python
• Top 100 Python Interview Questions

FAQs - Python Recursion से जुड़े सवाल

Q1. Recursion क्या होता है?

Recursion एक programming technique है जिसमें कोई function अपने आप को call करता है ताकि किसी बड़ी problem को छोटे-छोटे हिस्सों में तोड़कर solve किया जा सके।

Q2. Base Case क्यों जरूरी है?

Base Case के बिना recursive function कभी रुकेगा नहीं और Infinite Recursion की वजह से Python एक RecursionError देगा।

Q3. Recursion और Loop में क्या फर्क है?

Loop बार-बार एक ही block of code को execute करता है बिना नया function call बनाए, जबकि Recursion हर बार एक नया function call करता है जो memory में stack होता है। Recursion code को readable बनाता है लेकिन Loop आमतौर पर ज्यादा memory efficient होता है।

Q4. क्या Recursion हमेशा Loop से बेहतर होता है?

नहीं। Recursion कुछ problems (जैसे Tree Traversal, Backtracking) में ज्यादा clean और readable code देता है, लेकिन simple counting जैसी problems में Loop ज्यादा efficient होता है।

Q5. Infinite Recursion से कैसे बचें?

हमेशा एक सही Base Case define करें और यह सुनिश्चित करें कि हर recursive call, input को base case के करीब लेकर जाए।

Q6. Recursion किन जगहों पर सबसे ज्यादा use होता है?

Recursion का इस्तेमाल Tree और Graph traversal, Sorting algorithms (जैसे Merge Sort, Quick Sort), Backtracking problems, और Divide and Conquer algorithms में बहुत ज्यादा किया जाता है।