पाइथन कंट्रोल स्ट्रक्चर — Study Notes

1. परिचय

प्रोग्रामिंग में कंट्रोल स्ट्रक्चर वे संरचनाएँ हैं जो प्रोग्राम के निष्पादन के क्रम (Flow of Execution) को नियंत्रित करती हैं। पाइथन में प्रोग्राम के कथन सामान्यतः ऊपर से नीचे की ओर क्रम से निष्पादित होते हैं, परंतु जब हमें कुछ शर्तों के आधार पर निर्णय लेना हो या कुछ कार्यों को बार-बार दोहराना हो, तो हम कंट्रोल स्ट्रक्चर का उपयोग करते हैं। कंट्रोल स्ट्रक्चर तीन प्रकार के होते हैं: अनुक्रमिक (Sequential), चयनात्मक (Selection) और पुनरावृत्ति (Iteration)। अनुक्रमिक संरचना में कथन क्रम से चलते हैं, चयनात्मक संरचना (if-else) में शर्त के आधार पर एक पथ चुना जाता है, और पुनरावृत्ति संरचना (for, while) में कथनों का समूह बार-बार चलता है। इस अध्याय में इन सभी संरचनाओं का विस्तृत अध्ययन करेंगे।

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

चयनात्मक कथनों का उपयोग शर्तों के आधार पर निर्णय लेने के लिए किया जाता है। पाइथन में if, elif और else कीवर्ड से ये संरचनाएँ बनती हैं।

if कथन

यदि शर्त सत्य (True) हो तो उसका ब्लॉक निष्पादित होता है।

age = 18
if age >= 18:
    print("आप वयस्क हैं")

if-else कथन

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

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

if-elif-else कथन

अनेक शर्तों को क्रम से जाँचने के लिए elif का उपयोग होता है।

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

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

if के अंदर फिर से if लिखा जा सकता है।

num = 8
if num > 0:
    if num % 2 == 0:
        print("धनात्मक सम संख्या")

बूलियन एक्सप्रेशन

शर्तें हमेशा True या False में मूल्यांकन होती हैं। तुलनात्मक ऑपरेटर (==, !=, >, <, >=, <=) और तार्किक ऑपरेटर (and, or, not) शर्तों में उपयोग होते हैं।

x = 10
if x > 5 and x < 20:
    print("x 5 और 20 के बीच है")
if not (x == 0):
    print("x शून्य नहीं है")

3. पुनरावृत्ति कथन (Iteration/Loops)

जब किसी कथन या ब्लॉक को बार-बार निष्पादित करना होता है, तो लूप (Loop) का उपयोग होता है। पाइथन में दो प्रकार के लूप होते हैं: while और for।

while लूप

जब तक शर्त सत्य होती है, तब तक ब्लॉक चलता रहता है।

i = 1
while i <= 5:
    print(i)
    i = i + 1

उपरोक्त प्रोग्राम 1 से 5 तक की संख्याएँ प्रिंट करेगा। ध्यान दें कि लूप में सुधार (Update) अवश्य होना चाहिए, अन्यथा अनंत लूप (Infinite Loop) बन जाएगा।

while लूप में else

while लूप के साथ else का उपयोग किया जा सकता है; यह तब चलता है जब शर्त असत्य हो जाती है (बिना break के)।

i = 1
while i <= 3:
    print(i)
    i += 1
else:
    print("लूप समाप्त")

for लूप

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

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

यह 0,1,2,3,4 प्रिंट करेगा (5 शामिल नहीं)।

range() फ़ंक्शन

range(start, stop, step) तीन तर्क लेता है। - range(5) = 0 से 4 तक - range(2, 8) = 2 से 7 तक - range(1, 10, 2) = 1, 3, 5, 7, 9

for i in range(2, 10, 2):
    print(i, end=" ")

आउटपुट: 2 4 6 8

for लूप में स्ट्रिंग/लिस्ट

word = "PIE"
for ch in word:
    print(ch)

fruits = ["सेब", "आम", "केला"]
for f in fruits:
    print(f)

for लूप में else

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

4. break, continue और pass

break कथन

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

for i in range(1, 10):
    if i == 5:
        break
    print(i)

आउटपुट: 1 2 3 4 (5 पर लूप टूट गया)।

continue कथन

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

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

आउटपुट: 1 2 4 5 (3 को छोड़ दिया गया)।

pass कथन

pass कुछ नहीं करता; यह खाली ब्लॉक के लिए प्लेसहोल्डर है। यह सिंटैक्स त्रुटि से बचाता है।

if True:
    pass

5. नेस्टेड लूप (Nested Loops)

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

for i in range(1, 4):
    for j in range(1, 4):
        print(i * j, end=" ")
    print()

आउटपुट:

1 2 3
2 4 6
3 6 9

पैटर्न प्रिंटिंग (Pattern Printing)

नेस्टेड लूप से विभिन्न पैटर्न बनाए जा सकते हैं।

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

आउटपुट:

*
**
***
****
*****

6. संख्या गणना के प्रमुख प्रोग्राम

योग और औसत

n = int(input("कितनी संख्याएँ: "))
total = 0
for i in range(n):
    num = int(input("संख्या: "))
    total = total + num
avg = total / n
print("योग:", total, "औसत:", avg)

गुणन सारणी

num = int(input("संख्या: "))
for i in range(1, 11):
    print(num, "x", i, "=", num * i)

भाज्य (Factorial) और घातांक

n = 5
fact = 1
for i in range(1, n + 1):
    fact = fact * i
print("5 का भाज्य:", fact)

अभाज्य संख्या जाँच

num = int(input("संख्या: "))
is_prime = True
if num <= 1:
    is_prime = False
else:
    for i in range(2, num):
        if num % i == 0:
            is_prime = False
            break
if is_prime:
    print("अभाज्य संख्या है")
else:
    print("अभाज्य नहीं है")

फिबोनाची श्रृंखला

a, b = 0, 1
print(a, b, end=" ")
for i in range(8):
    c = a + b
    print(c, end=" ")
    a, b = b, c

7. बूलियन एक्सप्रेशन और शर्तों का मूल्यांकन

कंट्रोल स्ट्रक्चर को सही ढंग से समझने के लिए बूलियन एक्सप्रेशन का ज्ञान आवश्यक है। पाइथन में हर शर्त का मूल्यांकन True या False में होता है। तुलनात्मक ऑपरेटर जैसे ==, !=, >, <, >=, <= दो मानों की तुलना करके बूलियन परिणाम देते हैं। उदाहरण के लिए, यदि विद्यार्थी के अंक 40 से अधिक या बराबर हैं, तो वह उत्तीर्ण होता है। इस शर्त को marks >= 40 के रूप में लिखा जाता है। इसी प्रकार तार्किक ऑपरेटर and, or और not से दो या दो से अधिक शर्तों को जोड़ा जाता है। and तब सत्य होता है जब दोनों शर्तें सत्य हों, or तब सत्य होता है जब कम से कम एक शर्त सत्य हो, और not शर्त को उल्टा कर देता है। शर्तों का मूल्यांकन ऊपर बताए गए क्रम (घातांक, गुणा-भाग, जोड़-घटाव, फिर तुलना, फिर तार्किक) में होता है। कोष्ठक का उपयोग करके हम मूल्यांकन के क्रम को नियंत्रित कर सकते हैं। इसके अलावा, शून्य (0) को False और शून्येतर मानों को True माना जाता है, जबकि खाली स्ट्रिंग या खाली सूची भी False मानी जाती हैं। यह समझना महत्वपूर्ण है क्योंकि if कथन में किसी भी प्रकार का मान दिया जा सकता है।

8. लूप में else और पुनरावृत्ति का अनुप्रयोग

पाइथन में for और while लूप दोनों के साथ else ब्लॉक जोड़ा जा सकता है। यह else ब्लॉक तभी चलता है जब लूप सामान्य रूप से समाप्त होता है, अर्थात बिना break कथन के। यदि लूप break के कारण टूटता है, तो else ब्लॉक नहीं चलता। इसका एक व्यावहारिक उपयोग यह है कि हम यह पता लगा सकते हैं कि लूप पूरा चला या बीच में ही रुक गया। उदाहरण के लिए, अभाज्य संख्या की जाँच में यदि किसी भी संख्या से भाग नहीं लगता तो हम for-else का उपयोग करके सीधे 'अभाज्य है' प्रिंट कर सकते हैं। इसी प्रकार, खोज प्रोग्राम में यदि तत्व नहीं मिलता तो else ब्लॉक से संदेश दिखाया जा सकता है। लूप का उपयोग वास्तविक जीवन की समस्याओं जैसे बैंक में ब्याज की गणना, छात्रों के अंकों का प्रोसेसिंग, खरीदारी की बिल गणना, और अनेक प्रकार के संख्यात्मक अनुक्रम बनाने में होता है। इन प्रोग्रामों में पुनरावृत्ति की अवधारणा ही मुख्य आधार है, क्योंकि हमें समान क्रिया को बार-बार दोहराना पड़ता है। लूप में हर बार मान बदलने पर परिणाम भी बदलता है, इसलिए हमें ध्यानपूर्वक सोचकर ही शर्त और सुधार कथन लिखना चाहिए। उदाहरण के लिए, यदि हमें 1 से 100 तक की सम संख्याओं का योग निकालना हो, तो हम प्रारंभिक योग को 0 मानकर प्रत्येक सम संख्या को उसमें जोड़ते जाते हैं, जिसे संचायक (Accumulator) पैटर्न कहते हैं। इसी प्रकार गिनती (Counting) पैटर्न से किसी शर्त को पूरा करने वाली संख्याओं की संख्या ज्ञात की जाती है। इन पैटर्नों की समझ से परीक्षा के प्रोग्रामिंग प्रश्न सरलता से हल हो जाते हैं।

9. लूप नियंत्रण में सावधानियाँ

• while लूप में सुधार कथन को न भूलें, अन्यथा अनंत लूप बनेगा।
• break लूप से बाहर ले जाता है, continue अगली पुनरावृत्ति पर भेजता है।
• range() में अंतिम मान शामिल नहीं होता।
• इंडेंटेशन ब्लॉक की पहचान है; गलत इंडेंटेशन पर IndentationError।

graph TD
    A["कंट्रोल स्ट्रक्चर"] --> B["अनुक्रमिक"]
    A --> C["चयनात्मक"]
    A --> D["पुनरावृत्ति"]
    C --> E["if"]
    C --> F["if-else"]
    C --> G["if-elif-else"]
    C --> H["नेस्टेड if"]
    D --> I["for लूप"]
    D --> J["while लूप"]
    I --> K["range()"]
    D --> L["break, continue, pass"]
    J --> M["अनंत लूप से बचाव"]

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

कथन	कार्य	उदाहरण
if	शर्त सत्य होने पर ब्लॉक	if x > 0:
if-else	दो पथों में से एक	if/else
if-elif-else	अनेक शर्तें	ग्रेड निर्धारण
while	शर्त सत्य रहने तक	while i <= 5:
for	अनुक्रम पर पुनरावृत्ति	for i in range(5):
break	लूप समाप्त करना	break
continue	अगली पुनरावृत्ति	continue
pass	खाली ब्लॉक	pass

range() फ़ॉर्म	उत्पन्न मान
range(5)	0, 1, 2, 3, 4
range(2, 8)	2, 3, 4, 5, 6, 7
range(1, 10, 2)	1, 3, 5, 7, 9
range(10, 0, -2)	10, 8, 6, 4, 2

प्रोग्राम	तर्क
सम/विषम	num % 2
भाज्य	1 से n तक गुणा
अभाज्य	2 से n-1 से विभाज्यता
गुणन सारणी	1 से 10 तक गुणा
फिबोनाची	a, b = b, a+b

माइंड मैप

flowchart TD
    A["कंट्रोल स्ट्रक्चर"] --> B["if-elif-else"]
    A --> C["while लूप"]
    A --> D["for लूप"]
    A --> E["नेस्टेड लूप"]
    B --> F["निर्णय लेना"]
    C --> G["शर्त आधारित पुनरावृत्ति"]
    D --> H["range() आधारित"]
    E --> I["पैटर्न प्रिंटिंग"]
    A --> J["break: लूप तोड़ना"]
    A --> K["continue: छोड़ना"]
    A --> L["pass: प्लेसहोल्डर"]

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

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

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

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

1. break और continue के आउटपुट प्रश्नों में प्रत्येक पुनरावृत्ति को कागज पर हल करके देखें।
2. range(1, 10, 2) के मान लिखने का अभ्यास करें: 1, 3, 5, 7, 9।
3. नेस्टेड लूप में आंतरिक लूप बाहरी लूप के प्रत्येक चक्र में पूरा चलता है - याद रखें।
4. while लूप में "सुधार कथन" की अनुपस्थिति अनंत लूप बनाती है - यह आम परीक्षा प्रश्न है।
5. सम/विषम, भाज्य, अभाज्य, गुणन सारणी जैसे मानक प्रोग्राम स्वयं लिखने का अभ्यास करें।
6. if-elif-else में ग्रेड निर्धारण (marks ≥ 90 → A) जैसे उदाहरण स्मरण रखें।

निष्कर्ष

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