नियंत्रण प्रवाह — अध्ययन नोट्स

1. परिचय

नियंत्रण प्रवाह (Flow of Control) यह निर्धारित करता है कि प्रोग्राम के कथन किस क्रम में निष्पादित होंगे। डिफ़ॉल्ट रूप से पाइथन के कथन ऊपर से नीचे क्रम में चलते हैं, जिसे अनुक्रमिक (Sequential) नियंत्रण कहते हैं। परंतु कई बार हमें शर्तों के आधार पर निर्णय लेने (Selection) और कुछ कथनों को बार-बार दोहराने (Iteration) की आवश्यकता होती है। इसी के लिए नियंत्रण कथनों (Control Statements) का उपयोग होता है, जिनमें if-else और लूप्स (for, while) शामिल हैं। यह अध्याय प्रोग्रामिंग में तार्किक सोच विकसित करने के लिए अत्यंत महत्वपूर्ण है।

2. नियंत्रण संरचनाओं के प्रकार (Types of Control Structures)

1. अनुक्रमिक (Sequential): कथन ऊपर से नीचे क्रम में चलते हैं।
2. चयनात्मक (Selection/Decision Making): शर्त के अनुसार कथनों में से एक समूह चलता है। यह if, if-else, if-elif-else द्वारा किया जाता है।
3. पुनरावृत्ति (Repetition/Looping): कथनों का समूह बार-बार चलता है। यह for और while लूप द्वारा होता है।
4. कूद (Jump): कुछ विशेष परिस्थितियों में लूप या प्रोग्राम के प्रवाह को बदलना। यह break, continue, pass, return द्वारा होता है।

3. चयनात्मक कथन (Selection Statements)

if कथन

यदि शर्त सत्य हो तो कथनों का ब्लॉक चलता है।

x = 10
if x > 5:
    print("x, 5 से बड़ा है")

if-else कथन

शर्त सत्य होने पर if का ब्लॉक चलता है, अन्यथा else का।

num = int(input("संख्या दर्ज करें: "))
if num % 2 == 0:
    print("सम संख्या")
else:
    print("विषम संख्या")

if-elif-else कथन

कई शर्तों की जाँच के लिए elif का उपयोग होता है।

marks = int(input("अंक दर्ज करें: "))
if marks >= 90:
    grade = "A"
elif marks >= 75:
    grade = "B"
elif marks >= 60:
    grade = "C"
else:
    grade = "D"
print("ग्रेड:", grade)

नेस्टेड if (Nested if)

if के अंदर फिर से if का उपयोग किया जा सकता है।

x = 15
if x > 10:
    if x > 20:
        print("x बहुत बड़ा है")
    else:
        print("x 10 से बड़ा पर 20 से छोटा है")

4. पुनरावृत्ति कथन (Iterative Statements - Loops)

for लूप

for लूप किसी अनुक्रम (जैसे range, स्ट्रिंग, लिस्ट) के प्रत्येक मान के लिए चलता है।

for i in range(1, 6):
    print(i, end=" ")
print()

for ch in "पाइथन":
    print(ch)

range() फ़ंक्शन के रूप: - range(stop): 0 से stop-1 तक - range(start, stop): start से stop-1 तक - range(start, stop, step): start से stop-1 तक चरण में

for i in range(5):        # 0, 1, 2, 3, 4
    print(i)
for i in range(2, 10, 2): # 2, 4, 6, 8
    print(i)

while लूप

while लूप तब तक चलता है जब तक शर्त सत्य रहती है। शर्त के False होते ही लूप समाप्त हो जाता है।

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

while लूप में शर्त को अपडेट करना अनिवार्य है, अन्यथा लूप अनंत (Infinite) हो जाएगा।

5. जंप कथन (Jump Statements)

break कथन

break लूप को तुरंत समाप्त कर देता है।

for i in range(1, 11):
    if i == 5:
        break
    print(i)
# 1, 2, 3, 4 प्रिंट होंगे

continue कथन

continue वर्तमान पुनरावृत्ति को छोड़कर अगली पुनरावृत्ति पर जाता है।

for i in range(1, 8):
    if i == 4:
        continue
    print(i)
# 4 को छोड़कर सभी प्रिंट होंगे

pass कथन

pass एक खाली कथन है जो कुछ नहीं करता। यह उस स्थान पर लिखा जाता है जहाँ बाद में कोड लिखना हो।

for i in range(3):
    pass

else के साथ लूप

लूप के साथ else ब्लॉक तब चलता है जब लूप बिना break के पूर्ण रूप से समाप्त होता है।

for i in range(3):
    print(i)
else:
    print("लूप पूर्ण हुआ")

6. लूप में नेस्टिंग (Nested Loops)

एक लूप के अंदर दूसरा लूप चला सकते हैं। आंतरिक लूप बाहरी लूप के प्रत्येक पुनरावृत्ति के लिए पूर्ण रूप से चलता है।

for i in range(1, 4):
    for j in range(1, 4):
        print(i, j)
# कुल 9 पुनरावृत्तियाँ

पैटर्न प्रिंट करना

n = 5
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print("*", end=" ")
    print()

नेस्टेड लूप का प्रवाह समझना अत्यंत आवश्यक है। बाहरी लूप प्रत्येक बार जब एक पुनरावृत्ति करता है, तो आंतरिक लूप अपनी पूरी यात्रा पूर्ण करता है। इसलिए यदि बाहरी लूप m बार और आंतरिक लूप n बार चलता है, तो कुल m × n पुनरावृत्तियाँ होती हैं। पैटर्न प्रिंटिंग के प्रश्नों में प्रत्येक पंक्ति के लिए बाहरी लूप और प्रत्येक पंक्ति में वर्णों की संख्या के लिए आंतरिक लूप जिम्मेदार होता है। ऐसे प्रश्नों में range की सीमाओं को सोच-समझकर चुनना चाहिए, क्योंकि एक छोटी सी गलती से पूरा पैटर्न बदल जाता है।

7. व्यावहारिक उदाहरण (Practical Examples)

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

total = 0
for i in range(2, 101, 2):
    total = total + i
print("सम संख्याओं का योग:", total)

उदाहरण 2: संख्या सम या विषम की सूची

n = int(input("n दर्ज करें: "))
i = 1
while i <= n:
    if i % 2 == 0:
        print(i, "सम")
    else:
        print(i, "विषम")
    i = i + 1

उदाहरण 3: प्रथम 10 प्राकृत संख्याओं का योग

n = 10
s = 0
for i in range(1, n + 1):
    s += i
print("योग:", s)

उदाहरण 4: गुणा सारणी (Multiplication Table)

num = int(input("जिस संख्या की सारणी चाहिए: "))
for i in range(1, 11):
    print(num, "x", i, "=", num * i)

उदाहरण 5: किसी संख्या के अंकों का योग

जब हमें किसी संख्या के सभी अंकों का योग निकालना होता है, तो while लूप का उपयोग करते हुए प्रत्येक पुनरावृत्ति में % 10 से अंतिम अंक लिया जाता है और // 10 से संख्या को छोटा किया जाता है। यह अंकों को तोड़ने की शास्त्रीय विधि है।

n = int(input("कोई पूर्णांक दर्ज करें: "))
sum_digits = 0
while n > 0:
    sum_digits = sum_digits + (n % 10)
    n = n // 10
print("अंकों का योग:", sum_digits)

इसी प्रकार किसी संख्या को उल्टा करने, अंकों की गिनती करने या यह जाँचने के लिए कि संख्या पैलिंड्रोम है या नहीं, इसी while लूप तकनीक का उपयोग होता है। ये प्रोग्राम बोर्ड परीक्षा में सबसे अधिक पूछे जाने वाले उदाहरण हैं, इसलिए इन्हें ध्यान से समझना चाहिए।

8. अनंत लूप (Infinite Loop)

जब लूप की शर्त कभी False नहीं होती, तो अनंत लूप बनता है। इसे रोकने के लिए सही शर्त अपडेट या break का उपयोग करें।

# अनंत लूप से बचें
while True:
    ans = input("जारी रखें? (हाँ/नहीं): ")
    if ans == "नहीं":
        break

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

तालिका 1: चयनात्मक कथन

तालिका 2: for और while लूप की तुलना

तालिका 3: जंप कथन

माइंड मैप

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

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

1. while लूप में शर्त को अपडेट न करना, जिससे अनंत लूप बन जाता है और प्रोग्राम हैंग हो जाता है।
2. if के बाद कॉलन (:) न लगाना या इंडेंटेशन गलत करना, जिससे SyntaxError या IndentationError आती है।
3. break और continue के कार्य को उलटना; break लूप समाप्त करता है जबकि continue केवल पुनरावृत्ति छोड़ता है।
4. range(5) को 1 से 5 तक समझना; वास्तव में range(5) = 0, 1, 2, 3, 4 (0 से शुरू)।
5. == की बजाय = लिखना शर्तों में, जिससे असाइनमेंट हो जाता है।
6. नेस्टेड लूप में आंतरिक और बाहरी लूप की सीमाओं को उलट देना, जिससे गलत आउटपुट आता है।
7. for और else का संयोजन न समझना; else तब चलता है जब लूप बिना break के समाप्त होता है।

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

1. if-elif-else के प्रवाह को चरणबद्ध रूप से समझाएँ; ध्यान दें कि elif में से केवल एक ही ब्लॉक चलता है।
2. for लूप में range के तीनों रूपों (stop, start-stop, start-stop-step) को याद रखें।
3. while लूप के प्रश्नों में शर्त की अपडेट लाइन (जैसे count += 1) का उल्लेख करें।
4. break और continue के आउटपुट के प्रश्नों को ध्यान से हल करें।
5. नेस्टेड लूप में पुनरावृत्तियों की संख्या की गणना करने का अभ्यास करें।
6. पैटर्न प्रिंट करने वाले प्रोग्राम लिखने का अभ्यास करें, क्योंकि ये सामान्य प्रश्न हैं।
7. लूप के साथ else ब्लॉक की अवधारणा को उदाहरण सहित लिखें।

निष्कर्ष

नियंत्रण प्रवाह प्रोग्रामिंग की आत्मा है। if-else के माध्यम से हम निर्णय ले सकते हैं और for/while लूप के माध्यम से दोहराव को स्वचालित कर सकते हैं। break, continue और pass जैसे जंप कथन प्रवाह पर अतिरिक्त नियंत्रण देते हैं। इस अध्याय की सही समझ से विद्यार्थी ग्रेड निर्धारण, योग परिकलन, पैटर्न प्रिंटिंग जैसी वास्तविक समस्याओं के लिए कुशल प्रोग्राम लिख सकता है। अनंत लूप से बचने की सावधानी और शर्त अपडेट की आदत विद्यार्थी को त्रुटि-मुक्त प्रोग्रामिंग की ओर ले जाती है। यह अध्याय आगे के डेटा संरचना अध्यायों (स्ट्रिंग, लिस्ट, टपल, डिक्शनरी) के लिए आधार प्रदान करता है।