💻
⌨️
🖱️
🖥️
💾
← डैशबोर्ड पर वापस जाएँ
Font Size:

1. परिचय

प्रोग्रामिंग में किसी कार्य को बार-बार करने की आवश्यकता होती है। जैसे 1 से 100 तक की संख्याएँ प्रिंट करना, किसी सूची के सभी मानों को देखना या तालिका (पहाड़ा) छापना। प्रत्येक बार के लिए कोड दोहराने के बजाय लूप (Loop) का उपयोग होता है, जो कोड को निर्धारित बार या शर्त के अनुसार बार-बार चलाता है। साथ ही, कोड को पुनः उपयोग करने के लिए फंक्शन (Function) का उपयोग होता है, जो कोड के ब्लॉक को नाम देकर आवश्यकता पड़ने पर बार-बार बुलाया जा सकता है। इस अध्याय में हम for लूप, while लूप, range() फंक्शन, break, continue तथा फंक्शन की परिभाषा, पैरामीटर, आर्ग्यूमेंट और return का अध्ययन करेंगे।

2. for लूप (for Loop)

for लूप तब उपयोग होता है जब हमें पता हो कि कितनी बार दोहराना है, या किसी संग्रह (लिस्ट, स्ट्रिंग, रेंज) के सभी मानों पर जाना है।

for i in range(5):
    print(i)

यह 0, 1, 2, 3, 4 प्रिंट करेगा। लिस्ट के मानों पर चलने के लिए:

फल = ["सेब", "आम", "अंगूर"]
for फ in फल:
    print(फ)

यह सेब, आम, अंगूर क्रम से प्रिंट करेगा।

3. range() फंक्शन (range Function)

range() फंक्शन संख्याओं की श्रृंखला उत्पन्न करता है। इसके तीन रूप होते हैं:

  1. range(stop): 0 से stop-1 तक। जैसे range(5) = 0, 1, 2, 3, 4
  2. range(start, stop): start से stop-1 तक। जैसे range(2, 6) = 2, 3, 4, 5
  3. range(start, stop, step): step के अंतर से। जैसे range(0, 10, 2) = 0, 2, 4, 6, 8

ध्यान दें कि range में अंतिम मान शामिल नहीं होता (stop-1 तक)।

4. while लूप (while Loop)

while लूप शर्त सत्य (True) रहने तक चलता है। जब शर्त असत्य हो जाती है, तो लूप समाप्त हो जाता है। यह तब उपयोगी है जब दोहराने की संख्या पहले से ज्ञात न हो।

गिनती = 1
while गिनती <= 5:
    print(गिनती)
    गिनती = गिनती + 1

यह 1 से 5 तक प्रिंट करेगा। सावधानी: यदि शर्त कभी असत्य नहीं होती, तो अनंत लूप (Infinite Loop) बन जाता है, जो प्रोग्राम को रोक देता है।

5. break और continue (break and continue)

  1. break: लूप को तुरंत समाप्त (बाहर निकल) करता है। python for i in range(10): if i == 5: break print(i) यह 0, 1, 2, 3, 4 प्रिंट करके लूप से बाहर आ जाएगा।
  2. continue: वर्तमान पुनरावृत्ति (iteration) को छोड़कर अगली पर जाता है। python for i in range(5): if i == 2: continue print(i) यह 0, 1, 3, 4 प्रिंट करेगा (2 को छोड़कर)।

6. नेस्टेड लूप (Nested Loop)

जब किसी लूप के अंदर कोई और लूप हो, तो उसे नेस्टेड लूप कहते हैं। बाहरी लूप के प्रत्येक चक्कर में अंदरूनी लूप पूरा चलता है।

for i in range(1, 4):
    for j in range(1, 4):
        print(i, j)

यह (1,1), (1,2), (1,3), (2,1)... जैसे 9 जोड़े प्रिंट करेगा।

7. फंक्शन (Functions)

फंक्शन कोड का पुनः प्रयोग योग्य ब्लॉक है, जो किसी विशिष्ट कार्य को करता है। फंक्शन बनाने के लिए def कीवर्ड का उपयोग होता है।

def नमस्ते():
    print("नमस्ते दुनिया")

फंक्शन को बुलाने (Call) के लिए उसका नाम और कोष्ठक लिखते हैं:

नमस्ते()

पैरामीटर और आर्ग्यूमेंट (Parameters and Arguments)

फंक्शन में इनपुट देने के लिए पैरामीटर (परिभाषा में) और आर्ग्यूमेंट (बुलाते समय) का उपयोग होता है:

def स्वागत(नाम):          # नाम पैरामीटर
    print("नमस्ते", नाम)

स्वागत("राहुल")           # "राहुल" आर्ग्यूमेंट

return कथन (return Statement)

return फंक्शन का परिणाम (मान) लौटाता है:

def वर्ग(x):
    return x * x

परिणाम = वर्ग(4)          # परिणाम = 16
print(परिणाम)

8. फंक्शन के लाभ (Benefits of Functions)

  1. कोड की पुनः प्रयोगशीलता (Reusability)।
  2. प्रोग्राम छोटा और व्यवस्थित होता है।
  3. डिबगिंग (त्रुटि सुधार) आसान होती है।
  4. जटिल प्रोग्राम को छोटे भागों में बाँटा जा सकता है।
  5. एक बार लिखकर कई स्थानों पर उपयोग किया जा सकता है।

9. लूप और फंक्शन के व्यावहारिक उदाहरण (Practical Examples)

लूप और फंक्शन के संयोजन से जटिल समस्याओं का सरल समाधान संभव है। कुछ उदाहरण देखते हैं:

उदाहरण 1: 1 से 10 तक की संख्याओं का योग

योग = 0
for i in range(1, 11):
    योग = योग + i
print(योग)

यहाँ range(1, 11) 1 से 10 तक की संख्याएँ देता है, और प्रत्येक संख्या को योग में जोड़ा जाता है। अंत में योग = 55 प्रिंट होगा।

उदाहरण 2: किसी संख्या का पहाड़ा (गुणन सारणी)

n = 5
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

यह 5 का पहाड़ा 1 से 10 तक प्रिंट करेगा।

उदाहरण 3: फंक्शन से तालिका

def पहाड़ा(n):
    for i in range(1, 11):
        print(n, "x", i, "=", n * i)

पहाड़ा(7)

इस फंक्शन को किसी भी संख्या के लिए बुलाया जा सकता है, जैसे पहाड़ा(7), पहाड़ा(12)। इससे कोड की पुनः प्रयोगशीलता स्पष्ट होती है।

उदाहरण 4: लूप से सूची के मान प्रिंट करना

नाम = ["राहुल", "सीमा", "अमित"]
for न in नाम:
    print("नमस्ते", न)

इन उदाहरणों से यह स्पष्ट है कि for लूप निश्चित पुनरावृत्तियों के लिए, while लूप शर्त-आधारित दोहराव के लिए और फंक्शन पुनः प्रयोग योग्य कोड ब्लॉक के लिए उपयोगी हैं। जब किसी कार्य को कई बार करना हो और उसे अलग-अलग इनपुट के साथ दोहराना हो, तो फंक्शन के अंदर लूप लगाना सर्वोत्तम उपाय है। इस प्रकार, लूप्स और फंक्शन दोनों मिलकर प्रोग्रामिंग को शक्तिशाली, सुव्यवस्थित और रखरखाव में आसान बनाते हैं।

त्वरित पुनरावृत्ति तालिकाएँ

तालिका 1: लूप के प्रकार

लूप उपयोग उदाहरण
for निश्चित बार/संग्रह पर for i in range(5)
while शर्त सत्य तक while x < 10
नेस्टेड लूप लूप के अंदर लूप for i in range(3)

तालिका 2: range() के रूप

रूप परिणाम
range(5) 0, 1, 2, 3, 4
range(2, 6) 2, 3, 4, 5
range(0, 10, 2) 0, 2, 4, 6, 8

तालिका 3: break और continue

कथन कार्य
break लूप तुरंत समाप्त
continue इस पुनरावृत्ति को छोड़ें

माइंड मैप

graph TD A["लूप्स और फंक्शन"] --> B["for लूप"] A --> C["while लूप"] A --> D["range()"] A --> E["break / continue"] A --> F["फंक्शन"] B --> G["range या लिस्ट पर"] C --> H["शर्त सत्य तक"] D --> I["start, stop, step"] F --> J["def, पैरामीटर, return"] E --> K["break: समाप्त, continue: छोड़ें"] J --> L["पुनः प्रयोग योग्य कोड"]

महत्वपूर्ण आरेख (SVG)

while लूप का प्रवाह गिनती = 1 while गिनती <= 5 शर्त जाँच True False print(गिनती) गिनती = गिनती + 1 लूप समाप्त स्वर्ण नियम: while में गिनती बढ़ाना न भूलें, नहीं तो अनंत लूप बनेगा
फंक्शन का कार्य def वर्ग(x): return x * x परिणाम लौटाता है फंक्शन बुलाना परिणाम = वर्ग(4) आउटपुट print(परिणाम) -> 16 स्वर्ण नियम: return फंक्शन का परिणाम वापस लौटाता है स्वर्ण नियम: def से फंक्शन बनता है, नाम() से बुलाया जाता है

सामान्य गलतियाँ

  1. while लूप में गिनती बढ़ाना भूलना: गिनती = गिनती + 1 न लिखने पर शर्त हमेशा सत्य रहती है और अनंत लूप (Infinite Loop) बन जाता है।
  2. for और while में भ्रम: for का उपयोग निश्चित बार/संग्रह के लिए और while का शर्त के लिए होता है।
  3. range() का अंतिम मान गिनना: range(5) में 5 शामिल नहीं होता; यह 0 से 4 तक देता है।
  4. फंक्शन परिभाषित करके बुलाना भूलना: def से केवल फंक्शन बनता है; उसे नाम() लिखकर बुलाना आवश्यक है।
  5. def के बाद कोलन भूलना: def नाम(): के बाद कोलन और इंडेंटेशन अनिवार्य है।
  6. return का प्रिंट से भ्रम: return फंक्शन को मान लौटाता है (सहेजने के लिए), जबकि print स्क्रीन पर दिखाता है।
  7. continue को break समझना: continue केवल वर्तमान पुनरावृत्ति छोड़ता है, लूप जारी रहता है; break पूरा लूप रोकता है।

परीक्षा युक्तियाँ

  1. for और while लूप का सिंटैक्स तथा अंतर लिखना सीखें, यह बहुत लोकप्रिय प्रश्न है।
  2. range(start, stop, step) के तीनों रूपों के परिणाम याद रखें।
  3. दिए गए कोड का आउटपुट निकालने के लिए लूप की प्रत्येक पुनरावृत्ति को ध्यान से चलाएँ।
  4. break (पूरा लूप समाप्त) और continue (एक पुनरावृत्ति छोड़ना) का अंतर स्पष्ट करें।
  5. def, पैरामीटर, आर्ग्यूमेंट और return की परिभाषाएँ उदाहरण सहित लिखें।
  6. फंक्शन के लाभ (पुनः प्रयोगशीलता, डिबगिंग में सुगमता) याद रखें।
  7. नेस्टेड लूप के व्यवहार (बाहरी लूप के प्रत्येक चक्कर में अंदरूनी पूरा चलता है) को समझें।

निष्कर्ष

लूप और फंक्शन प्रोग्रामिंग की दो सबसे शक्तिशाली अवधारणाएँ हैं। for लूप निश्चित बार और while लूप शर्त के अनुसार कोड दोहराते हैं। range() संख्याओं की श्रृंखला उत्पन्न करता है, break लूप को तुरंत समाप्त करता है और continue एक पुनरावृत्ति छोड़ता है। फंक्शन def कीवर्ड से बनते हैं, पैरामीटर के माध्यम से इनपुट लेते हैं और return से परिणाम लौटाते हैं। लूप्स दोहराए जाने वाले कार्यों को स्वचालित करते हैं, जबकि फंक्शन कोड को पुनः प्रयोग योग्य, व्यवस्थित और सरल बनाते हैं। इन अवधारणाओं की ठोस समझ विद्यार्थियों को जटिल प्रोग्राम लिखने, त्रुटियाँ सुधारने और वास्तविक समस्याओं का कुशल समाधान करने में सक्षम बनाती है। इस अध्याय के साथ पाइथन प्रोग्रामिंग की मूलभूत यात्रा पूर्ण होती है।