Python me Recursion kya hota hai?

Recursion ek aisi technique hai jisme function khud apne aap ko call karta hai. Jaise aap ek darwaza kholte hain aur andar jaate hain, phir aur ek darwaza, phir aur — jab tak aakhri kamra na aaye. Wapas aate waqt har darwaza band karte jaate hain. Exactly yahi Recursion me hota hai.

Har recursive function me 2 zaroori cheezein honi chahiye :-

Base Case — woh condition jab recursion rukti hai (warna infinite loop)
Recursive Case — function khud ko chhote problem ke saath call karta hai

Is page me yeh sab sikhenge :-

1. Recursion kaise kaam karta hai — step by step
2. Countdown — simple recursion example
3. Factorial — classic recursion problem
4. Fibonacci Series
5. Sum of digits
6. String reverse karna
7. Recursion vs Loop
8. RecursionError — jab base case bhool jaate hain

1. Recursion Kaise Kaam Karta Hai?

Recursion me function har baar chhoti problem ke saath apne aap ko call karta hai, jab tak base case na aa jaye. Phir sab answers wapas aate hain (unwind).

Syntax
def recursive_function(problem): if base_case: # yahan rukna hai return answer else: return recursive_function(smaller_problem) # apne aap ko call

Example 1: Simple countdown — recursion ka flow samjho

Python

In [1]:

def countdown(n):
    if n == 0:                # Base Case — yahaan rukna hai
        print("Go!")
        return
    print(n)
    countdown(n - 1)          # Recursive Case — chhoti problem se call

countdown(5)

Output

Example 2: Call trace — recursion ka flow step by step dekhna

Python

In [1]:

def sum_to_n(n, depth=0):
    indent = "  " * depth
    print(f"{indent}sum_to_n({n}) called")

    if n == 0:                          # Base Case
        print(f"{indent}Base case! return 0")
        return 0

    result = n + sum_to_n(n - 1, depth + 1)   # Recursive call
    print(f"{indent}sum_to_n({n}) = {result}")
    return result

print("Answer:", sum_to_n(4))

Output

2. Factorial — Classic Recursion Problem

Factorial ka matlab hai ek number ko usse chhote saare numbers se multiply karna. n! = n × (n-1) × (n-2) × ... × 1
Jaise: 5! = 5 × 4 × 3 × 2 × 1 = 120

Example 1: Factorial — recursion se

Python

In [1]:

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

print("0! =", factorial(0))
print("1! =", factorial(1))
print("5! =", factorial(5))
print("6! =", factorial(6))
print("10! =", factorial(10))

Output

Example 2: Factorial ka step-by-step execution — 5! kaise calculate hota hai

Python

In [1]:

def factorial_trace(n):
    if n == 0 or n == 1:
        print(f"  factorial({n}) = 1  ← Base Case")
        return 1
    result = n * factorial_trace(n - 1)
    print(f"  factorial({n}) = {n} × factorial({n-1}) = {result}")
    return result

print("5! ka trace:")
ans = factorial_trace(5)
print(f"\nFinal Answer: {ans}")

Output

3. Fibonacci Series

Fibonacci series me har number, usse pehle ke do numbers ka sum hota hai. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34...
Formula: fib(n) = fib(n-1) + fib(n-2)

Example 1: Fibonacci — recursion se nth number nikalna

Python

In [1]:

def fib(n):
    if n == 0:          # Base Case 1
        return 0
    if n == 1:          # Base Case 2
        return 1
    return fib(n-1) + fib(n-2)   # Recursive Case

print("fib(0) =", fib(0))
print("fib(1) =", fib(1))
print("fib(6) =", fib(6))
print("fib(10) =", fib(10))

Output

Example 2: Pehle N Fibonacci numbers print karna

Python

In [1]:

def fib(n):
    if n <= 0: return 0
    if n == 1: return 1
    return fib(n-1) + fib(n-2)

n = 10
print(f"Pehle {n} Fibonacci numbers:")
series = [fib(i) for i in range(n)]
print(series)

Output

4. Sum of Digits

Kisi number ke saare digits ka sum nikalna recursion se — jaise 1234 → 1 + 2 + 3 + 4 = 10.

Example 1: Digits ka sum — recursion se

Python

In [1]:

def digit_sum(n):
    n = abs(n)              # negative numbers handle karo
    if n < 10:              # Base Case — single digit
        return n
    return (n % 10) + digit_sum(n // 10)   # last digit + baaki

# n % 10  → last digit milti hai (1234 % 10 = 4)
# n // 10 → last digit hat jaati hai (1234 // 10 = 123)

print("digit_sum(0)    =", digit_sum(0))
print("digit_sum(9)    =", digit_sum(9))
print("digit_sum(123)  =", digit_sum(123))    # 1+2+3 = 6
print("digit_sum(9999) =", digit_sum(9999))   # 9+9+9+9 = 36

Output

Example 2: Power function — recursion se a^b nikalna

Python

In [1]:

def power(base, exp):
    if exp == 0:                    # Base Case: koi bhi number^0 = 1
        return 1
    return base * power(base, exp - 1)   # Recursive Case

print("2^0  =", power(2, 0))
print("2^5  =", power(2, 5))
print("3^4  =", power(3, 4))
print("10^3 =", power(10, 3))

Output

5. String Reverse Karna

String ko recursion se reverse karna — pehla character end me daalo aur baaki string ko recursion se reverse karo.

Example 1: String reverse — recursion se

Python

In [1]:

def reverse_string(s):
    if len(s) == 0:          # Base Case — empty string
        return ""
    return reverse_string(s[1:]) + s[0]   # baaki reverse karo + pehla char end me

print(reverse_string("Python"))
print(reverse_string("Namaste"))
print(reverse_string("racecar"))  # palindrome!

Output

Example 2: Palindrome check — recursion se

Python

In [1]:

def is_palindrome(s):
    if len(s) <= 1:                  # Base Case — 0 ya 1 char
        return True
    if s[0] != s[-1]:                # Pehla aur aakhri alag hai
        return False
    return is_palindrome(s[1:-1])   # beech ki string check karo

words = ["madam", "racecar", "python", "level", "hello"]
for word in words:
    result = "Palindrome!" if is_palindrome(word) else "Nahi hai."
    print(f"'{word}' — {result}")

Output

6. Recursion vs Loop — Kab Kaun?

Recursion aur Loop dono same kaam kar sakte hain — lekin dono ke apne apne advantages hain.

Feature	Recursion	Loop
Code length	Chhota, elegant	Thoda lamba
Speed	Relatively slow	Fast
Memory	Stack use karta hai (zyada)	Kam memory
Samajhna	Thoda mushkil	Aasaan
Best for	Tree, graph, divide & conquer	Simple repetition

Example 1: Factorial — Loop vs Recursion

Python

In [1]:

# Loop se factorial
def factorial_loop(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Recursion se factorial
def factorial_recursion(n):
    if n <= 1:
        return 1
    return n * factorial_recursion(n - 1)

n = 7
print(f"Loop     : {n}! = {factorial_loop(n)}")
print(f"Recursion: {n}! = {factorial_recursion(n)}")
print("Dono ka result same hai!")

Output

7. RecursionError — Jab Base Case Bhool Jaayein

Agar base case nahi likha ya galat likha, toh function infinite baar call hota rehta hai aur Python ek RecursionError deta hai — "maximum recursion depth exceeded".

Example 1: RecursionError — base case missing

Python

In [1]:

# GALAT — Base case nahi hai
def infinite_recursion(n):
    print(n)
    return infinite_recursion(n + 1)  # kabhi nahi rukega!

# try-except se error handle karte hain
try:
    infinite_recursion(1)
except RecursionError as e:
    print("\nRecursionError pakda gaya!")
    print("Reason: Base case missing tha.")

Output

Example 2: Python ka default recursion limit dekhna

Python

In [1]:

import sys
print("Python ka default recursion limit:", sys.getrecursionlimit())

# Recursion se bachne ke liye — hamesha base case check karo
print("\nSafe recursion ka formula:")
print("1. Pehle base case likhna")
print("2. Har call me problem chhoti honi chahiye")
print("3. Base case tak pahunchna guaranteed hona chahiye")

Output

Quick Summary — Recursion ek nazar me

Concept	Matlab	Example
Recursion	Function apne aap ko call karta hai	def f(n): return f(n-1)
Base Case	Recursion kahan rukegi	if n == 0: return 1
Recursive Case	Chhoti problem se call	return n * f(n-1)
Factorial	n! = n × (n-1)!	factorial(5) = 120
Fibonacci	fib(n) = fib(n-1) + fib(n-2)	0,1,1,2,3,5,8...
RecursionError	Base case nahi — infinite loop	max depth exceeded
Stack	Har call memory me store hoti hai	Call Stack

Previous Next