Chapter 6: Functions — Code को Reusable बनाना

🏗️ Top-Down Approach — Structure

✅ Functions के फायदे

• Reusability: एक बार लिखो, कहीं भी बार-बार उपयोग करो।
• Readability: बड़ा code छोटे, समझने लायक टुकड़ों में।
• Debugging आसान: गलती किस function में है, ढूँढना आसान।
• Team Collaboration: अलग-अलग functions अलग लोग लिख सकते हैं।

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def main():
    x, y = 10, 4
    print("Sum:", add(x, y))
    print("Difference:", subtract(x, y))

main()

x = 100    # global

def test():
    x = 50   # local — alag variable hai!
    print("Andar x =", x)

test()
print("Bahar x =", x)

🔑 global Keyword — जब सच में बदलना हो

count = 0

def increment():
    global count      # bina isake UnboundLocalError aayega
    count += 1
    print("Andar:", count)

increment()
increment()
print("Bahar:", count)

1️⃣ Default Parameters

def greet(name="Guest"):
    print("Namaste,", name)

greet("Aditya")
greet()

2️⃣ Keyword Arguments

def student(name, age):
    print(name, "is", age, "years old")

student(age=18, name="Ravi")   # order ulta, phir bhi sahi!

3️⃣ *args — कई Positional Values

def total(*numbers):
    print("Mile:", numbers)     # tuple
    print("Sum:", sum(numbers))

total(10, 20, 30)
total(5, 15, 25, 35)

4️⃣ **kwargs — कई Keyword Values

def info(**details):
    for key, value in details.items():
        print(key, "=", value)

info(name="Priya", age=21, city="Lucknow")

def factorial(n):
    if n == 0 or n == 1:     # BASE CASE — yahin rukega
        return 1
    else:
        return n * factorial(n - 1)   # khud ko call kar raha hai

print(factorial(5))

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

for i in range(7):
    print(fibo(i), end=" ")

⚖️ Recursion vs Loop

🧮 math Module

import math
print(math.sqrt(49))       # 7.0
print(math.factorial(5))   # 120
print(math.ceil(3.2))      # 4 (upar)
print(math.floor(3.9))     # 3 (neeche)
print(math.pi)              # 3.14159...

🎲 random Module

import random
print(random.randint(1, 10))        # 1-10 ke beech koi number
print(random.choice(["A","B","C"])) # list se koi ek

🕒 datetime Module

from datetime import date
today = date.today()
print("Aaj ki date:", today)

birth_year = 2005
age = today.year - birth_year
print("Age:", age)

📥 Import के 3 तरीके

import math                    # poora module — math.sqrt()
from math import sqrt          # sirf ek function — seedha sqrt()
import math as m               # chhota naam — m.sqrt()

print(math.sqrt(16))
print(sqrt(25))
print(m.sqrt(36))

Q1. Default vs Passed Argument

def power(base, exp=2):
    return base ** exp

print(power(3))
print(power(3, 3))

Q2. Local Variable का Scope

def show():
    msg = "Hello"
    print(msg)

show()
print(msg)

Q3. Return न होने पर

def test():
    x = 5

result = test()
print(result)

Q4. *args का Behavior

def total(*nums):
    return sum(nums)

print(total(1, 2, 3, 4))
print(total())

Q5. global के बिना Error

n = 5
def change():
    n = n + 1
    print(n)
change()

Q6. Recursion Trace

def f(n):
    if n == 0:
        return 0
    return n + f(n-1)

print(f(4))

Q7. **kwargs Dictionary

def info(**data):
    print(type(data))
    print(data)

info(x=1, y=2)

Q8. Keyword Argument Order

def sub(a, b):
    return a - b

print(sub(b=3, a=10))

Program 1 — Prime Check Function (Chapter 2 जैसा logic, अब function में)

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

for num in range(2, 20):
    if is_prime(num):
        print(num, end=" ")

Program 2 — Recursive Sum of Digits

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

print(digit_sum(1234))

Program 3 — Simple Interest Calculator (Function + Default)

def simple_interest(p, r, t=1):    # t ka default 1 saal
    return (p * r * t) / 100

print(simple_interest(5000, 8, 3))
print(simple_interest(5000, 8))     # 1 saal default se

Program 4 — GCD Function (Recursion से)

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

print(gcd(48, 18))

Program 5 — Multiple Marks Average (*args से)

def average(*marks):
    if len(marks) == 0:
        return 0
    return sum(marks) / len(marks)

print(average(85, 90, 78, 92))
print(average(70, 60))

Program 6 — Circle Calculator (math module से)

import math

def circle_area(r):
    return round(math.pi * r ** 2, 2)

def circle_circumference(r):
    return round(2 * math.pi * r, 2)

radius = 7
print("Area:", circle_area(radius))
print("Circumference:", circle_circumference(radius))

Program 7 — Student Profile Card (**kwargs)

def profile(name, **extra):
    print("Name:", name)
    for key, val in extra.items():
        print(f"{key}: {val}")

profile("Aditya", city="Lucknow", course="Python", batch=2026)

• Function = reusable code block; Modular Programming = बड़े problem को functions में तोड़ना; Top-Down = पहले design, फिर टुकड़े।
• def से function बनता है; parameters से values अंदर आती हैं; return optional — न हो तो None।
• Local variable function तक सीमित; Global पूरे program में; बदलने के लिए global keyword ज़रूरी (नहीं तो UnboundLocalError)।
• Default parameter — missing argument का fallback; Keyword argument — नाम से, order मायने नहीं; *args — tuple में extra positional; **kwargs — dict में extra keyword।
• DocString """triple quotes""" में — func.__doc__ या help() से पढ़ते हैं।
• Recursion = function खुद को call करे; base case ज़रूरी वरना RecursionError; Factorial व Fibonacci classic examples।
• Built-in functions बिना import (len, sum, sorted, divmod...); Modules import करके (math, random, datetime)।
• Import के 3 तरीके: import module; from module import func; import module as alias।

❓ A. Multiple Choice Questions (50)

📝 B. 15 Theory Questions (Short Answers)

1. Function क्या है? इसके फायदे लिखिए।Function reusable code का block है जो specific task करता है। फायदे — code reusability, readability, आसान debugging, team collaboration।
2. Modular Programming व Top-Down Approach समझाइए।Modular Programming = बड़े program को छोटे functions में तोड़ना; Top-Down = पहले main design सोचना, फिर उसे sub-problems (functions) में divide करना।
3. Parameter व Argument में अंतर बताइए।Parameter function definition में दिया नाम है (def f(a, b):); Argument function call के समय दी गई असली value है (f(5, 10))।
4. return statement का क्या काम है? बिना return क्या होता है?return function को terminate करके value वापस caller को भेजता है। बिना return function automatically None देता है।
5. Local व Global variable में अंतर बताइए।Local variable function के अंदर बनता है, सिर्फ वहीं access होता है; Global variable function के बाहर बनता है, पूरे program में access होता है।
6. global keyword की ज़रूरत कब पड़ती है?जब function के अंदर किसी global variable की value बदलनी हो — बिना global keyword के Python उसे नया local variable मान लेता है और UnboundLocalError देता है।
7. Default parameter व Keyword argument में अंतर बताइए।Default parameter definition में fallback value देता है (def f(x=5)); Keyword argument call के समय नाम से value देता है (f(x=10)) — order irrelevant हो जाता है।
8. *args और **kwargs में अंतर उदाहरण सहित लिखिए।*args variable संख्या के positional arguments को tuple में लेता है — def f(*args)। **kwargs variable संख्या के keyword arguments को dictionary में लेता है — def f(**kwargs)।
9. DocString क्या है? कैसे लिखते व पढ़ते हैं?Function/class की शुरुआत में triple quotes (""" """) में लिखी documentation string। लिखना: def f(): """explanation"""; पढ़ना: f.__doc__ या help(f)।
10. Recursion क्या है? Base case क्यों ज़रूरी है?Function का खुद को call करना, जब तक base case (रुकने की शर्त) पूरी न हो। Base case के बिना function अनंत बार खुद को call करता रहेगा — RecursionError आएगी।
11. Factorial का recursive algorithm लिखिए।def factorial(n): if n==0 or n==1: return 1; else: return n * factorial(n-1) — base case n=0 या 1 पर 1 return करता है, बाकी n × पिछले factorial से गुणा।
12. Built-in function किसे कहते हैं? 4 उदाहरण दीजिए।Python के साथ पहले से मौजूद functions जो बिना import के उपयोग होते हैं — len(), sum(), max(), sorted()।
13. Module क्या है? Import के 3 तरीके लिखिए।Module pre-written code वाली file है (math, random)। तरीके — import module_name; from module_name import function; import module_name as alias।
14. math module के 4 उपयोगी functions लिखिए।math.sqrt() (square root), math.factorial() (factorial), math.ceil() (ऊपर round), math.floor() (नीचे round), math.pi (constant)।
15. Recursion और Loop में कब कौन-सा उपयोग करना चाहिए?Recursion — जब समस्या naturally recursive हो (factorial, tree traversal, Fibonacci) — code छोटा व elegant बनता है। Loop — साधारण repetition के लिए, कम memory लेता है, ज़्यादा efficient होता है।