निर्णय लेना — if, elif, else

वह समस्या जिसे हम हल कर रहे हैं

पिछले अध्याय में हमने सवाल पूछना सीखा — age >= 18 सच है या झूठ। लेकिन जवाब जानकर भी प्रोग्राम कुछ नहीं कर रहा था, बस True या False प्रिंट कर रहा था।

अब उस जवाब को काम में लाने का समय है। शर्त सच हो तो एक रास्ता, झूठ हो तो दूसरा। यही प्रोग्रामिंग का वह पल है जहाँ कोड सिर्फ़ क़दमों की लिस्ट नहीं रहता — वह फ़ैसले लेने लगता है।

और पायथन में एक बात कई दूसरी प्रोग्रामिंग भाषाओं से अलग है: कौन-सी लाइनें शर्त के अंदर हैं और कौन-सी बाहर, यह ख़ाली जगह (whitespace) से तय होता है। कर्ली ब्रैकेट {} नहीं होते। पहले अजीब लगता है, फिर अच्छा लगने लगता है — क्योंकि जो कोड देखने में व्यवस्थित है, वही असल में व्यवस्थित है।

इस अध्याय के बाद आप यह कर पाएँगे

• if से शर्त के हिसाब से कोड चलाना
• else से दूसरा रास्ता देना, और elif से कई रास्ते
• इंडेंटेशन सही लिखना, और IndentationError पढ़कर ठीक करना
• समझना कि शर्तों का क्रम क्यों मायने रखता है — सबसे बड़ा जाल यहीं है
• एक शर्त के अंदर दूसरी शर्त रखना, और समझना कि कब इससे बचना है

पहले यह आना चाहिए: True और False — सवाल पूछना सीखना।

सबसे आसान रूप

age = 22

if age >= 18:
    print("You may enter")

print("Program finished")

You may enter
Program finished

इसकी बनावट को तीन हिस्सों में बाँटा जा सकता है:

1. if शब्द, फिर एक शर्त
2. शर्त के आख़िर में एक कोलन : — इसका छूट जाना सबसे आम ग़लती है
3. अगली लाइनें चार स्पेस अंदर — यही अंदर वाली लाइनें शर्त के तहत आती हैं

अगर age 15 होता, तो पहला print नहीं चलता, लेकिन आख़िरी print फिर भी चलता — क्योंकि वह शर्त के बाहर है।

इंडेंटेशन ही मतलब है

इन दो प्रोग्रामों में अक्षर लगभग एक जैसे हैं, लेकिन काम बिल्कुल अलग:

score = 30

if score >= 50:
    print("Passed")
    print("Certificate issued")

यह प्रोग्राम चलाने पर टर्मिनल में कुछ भी नहीं आता — दोनों लाइनें शर्त के अंदर हैं, और शर्त झूठी है।

score = 30

if score >= 50:
    print("Passed")
print("Certificate issued")

Certificate issued

दूसरा print अब शर्त के बाहर है, इसलिए वह हमेशा चलता है — और फ़ेल होने वाले के नाम भी सर्टिफ़िकेट छप गया। एक लाइन का इंडेंटेशन ग़लत हो तो बिज़नेस का नियम ही टूट जाता है, और पायथन कोई एरर नहीं देता — दोनों सही कोड हैं।

चार स्पेस, टैब नहीं। पायथन दोनों मानता है, लेकिन एक ही फ़ाइल में दोनों मिला दें तो TabError आता है, और उसे ढूँढना मुश्किल है क्योंकि स्क्रीन पर टैब और स्पेस एक जैसे दिखते हैं। अध्याय 1 में आपने जो VS Code इंस्टॉल किया था, उसमें पायथन फ़ाइल में Tab दबाने पर चार स्पेस लगते हैं — यह उसकी डिफ़ॉल्ट सेटिंग है, और चार स्पेस ही पायथन का आधिकारिक तरीक़ा है।

else — दूसरा रास्ता

age = 15

if age >= 18:
    print("You may enter")
else:
    print("Sorry, adults only")

Sorry, adults only

else के साथ कोई शर्त नहीं होती, क्योंकि उसकी शर्त पहले ही कही जा चुकी है — "ऊपर वाली कोई भी सच न हो तो"। if और else में से ठीक एक ही चलेगा, कभी दोनों नहीं, कभी कोई भी नहीं — ऐसा भी नहीं।

elif — कई रास्ते

marks = 72

if marks >= 80:
    grade = "A"
elif marks >= 70:
    grade = "B"
elif marks >= 60:
    grade = "C"
elif marks >= 40:
    grade = "D"
else:
    grade = "F"

print(f"Marks {marks} gives grade {grade}")

Marks 72 gives grade B

elif का मतलब है "वरना अगर"। यहाँ होता यह है — पायथन ऊपर से नीचे जाता है, पहली जो शर्त सच मिलती है उसका काम करता है, फिर पूरी चेन छोड़कर बाहर निकल जाता है। बाक़ी शर्तें जाँचता भी नहीं।

marks = 72 हो तो: 72 >= 80 झूठ, 72 >= 70 सच → grade = "B", और बस। 72 >= 60 और 72 >= 40 भी सच हैं, लेकिन उन्हें देखा ही नहीं जाता।

सबसे बड़ा जाल यहीं है

elif "पहली सच वाली पर रुक जाता है" — इस एक बात का नतीजा यह है कि शर्तों का क्रम ग़लत हो तो प्रोग्राम चलता है, कोई एरर नहीं देता, बस ग़लत जवाब देता है:

marks = 95

if marks >= 40:
    grade = "Pass"
elif marks >= 80:
    grade = "Excellent"
else:
    grade = "Fail"

print(grade)

Pass

95 नंबर लाकर भी Excellent नहीं आया। क्योंकि 95 >= 40 पहले ही सच हो गया, और पायथन वहीं रुक गया — दूसरी शर्त कभी जाँची ही नहीं गई।

नियम याद रखिए: सबसे सख़्त या सबसे ख़ास शर्त पहले लिखिए, सबसे ढीली आख़िर में। नंबर की सीमाओं के साथ काम करते हों तो बड़े से छोटे की ओर उतरिए, जैसे ऊपर ग्रेड वाले उदाहरण में।

यह बग इतना चुपचाप है कि आँखों से देखे बिना पकड़ने का कोई तरीक़ा नहीं। इसलिए शर्तों की चेन लिखने के बाद आदत डालिए — हर शाखा के लिए एक-एक वैल्यू देकर चलाकर देखना। ऊपर का ग्रेड वाला कोड 95, 72, 65, 45 और 20 — इन पाँच वैल्यू से चलाएँ तो पाँच अलग जवाब आने चाहिए। कोई भी दो एक जैसे आएँ, तो क्रम में गड़बड़ है।

शर्त के अंदर शर्त

is_logged_in = True
is_admin = False

if is_logged_in:
    if is_admin:
        print("Welcome, admin")
    else:
        print("Welcome, user")
else:
    print("Please log in")

Welcome, user

अंदर वाला if चार स्पेस अंदर है, क्योंकि वह बाहर वाले if के तहत है, और उसकी अपनी print वाली लाइनें आठ स्पेस अंदर हैं। यह काम करता है, लेकिन जितने स्तर बढ़ते हैं, कोड पढ़ना उतना मुश्किल होता है। कई बार and से वही बात और साफ़ कही जा सकती है:

is_logged_in = True
is_admin = False

if is_logged_in and is_admin:
    print("Welcome, admin")
elif is_logged_in:
    print("Welcome, user")
else:
    print("Please log in")

Welcome, user

दोनों में से कौन-सा बेहतर है, यह इस पर निर्भर है कि कौन-सा पढ़ने में आसान लगे। तीन स्तर से ज़्यादा अंदर चले जाएँ तो रुकिए और दोबारा सोचिए — यह लगभग हमेशा इशारा है कि शर्तों को किसी और तरह सजाया जा सकता है।

इनपुट की जाँच

अब हमारे पास वह औज़ार है, जिससे पहले के एक अध्याय में अधूरी छूटी समस्या हल की जा सकती है — यूज़र कुछ भी न लिखे या कोई शब्द लिख दे तो क्या होगा:

raw = input("Your age: ").strip()

if raw == "":
    print("You did not type anything")
elif raw.isdigit():
    age = int(raw)
    if age >= 18:
        print(f"Age {age}: you may enter")
    else:
        print(f"Age {age}: adults only")
else:
    print(f"'{raw}' is not a whole number")

Your age: twenty
'twenty' is not a whole number

isdigit() एक नया मेथड है — बताता है कि स्ट्रिंग के सारे अक्षर अंक हैं या नहीं। int() को भेजने से पहले जाँचने का यही आसान तरीक़ा है, और इससे ValueError आता ही नहीं। (isdigit() नेगेटिव नंबर या दशमलव नहीं मानता — उनके लिए आगे try सीखना होगा।)

एक पूरा उदाहरण

fare.py:

# Work out a ticket fare from age and day of week
age = int(input("Passenger age : "))
day = input("Day of week   : ").strip().lower()

base_fare = 120.0

# Most specific rule first, loosest last
if age < 5:
    fare = 0.0
    category = "Infant"
elif age < 18:
    fare = base_fare * 0.5
    category = "Child"
elif age >= 60:
    fare = base_fare * 0.7
    category = "Senior"
else:
    fare = base_fare
    category = "Adult"

is_weekend = day == "saturday" or day == "sunday"
if is_weekend:
    fare = fare * 1.2

print()
print(f"Category : {category}")
print(f"Weekend  : {is_weekend}")
print(f"Fare     : {fare:.2f}")

Passenger age : 65
Day of week   : Sunday

Category : Senior
Weekend  : True
Fare     : 100.80

दो डिज़ाइन फ़ैसलों पर ध्यान दीजिए। पहला, उम्र वाली शर्तें elif से जुड़ी हैं, क्योंकि एक यात्री ठीक एक ही श्रेणी में आएगा। दूसरा, वीकेंड वाली शर्त अलग if है, क्योंकि वह एक स्वतंत्र सवाल है — उम्र जो भी हो, वीकेंड का अतिरिक्त किराया अलग से जुड़ता है। कौन-सा elif होगा और कौन-सा अलग if, यह फ़ैसला ही शर्तें लिखने का असली काम है।

कुछ टूटी हुई हालतें और उनका हल

SyntaxError: expected ':' if, elif या else वाली लाइन के आख़िर में कोलन नहीं लगा।

IndentationError: expected an indented block after 'if' statement if के बाद वाली लाइन अंदर नहीं खिसकाई गई। शर्त के अंदर कम से कम एक लाइन होनी चाहिए।

IndentationError: unexpected indent कोई लाइन बिना वजह अंदर चली गई है। देखिए वह लाइन किस ब्लॉक का हिस्सा होनी चाहिए।

TabError: inconsistent use of tabs and spaces in indentation एक ही फ़ाइल में टैब और स्पेस मिला दिए गए हैं। एडिटर में "convert indentation to spaces" चला दीजिए।

SyntaxError — elif या else अकेला खड़ा है elif और else हमेशा किसी if के साथ होते हैं, और उनका इंडेंटेशन उसी if के बराबर होना चाहिए।

TypeError: '>=' not supported between instances of 'str' and 'int' input() की वैल्यू बदलना भूल गए। int(input(...)) लिखिए।

शर्त सही लग रही है लेकिन ग़लत रास्ते जा रही है क्रम देखिए। ढीली शर्त पहले हो तो सख़्त शर्त कभी जाँची ही नहीं जाती। हर शाखा के लिए एक-एक वैल्यू देकर चलाकर देखिए।

आपकी बारी

bmi.py नाम की एक फ़ाइल लिखिए, जो लंबाई (मीटर में) और वज़न (किलो में) लेकर BMI निकाले और उसकी श्रेणी बताए।

फ़ॉर्मूला: bmi = weight / (height * height)

श्रेणियाँ:

• 18.5 से कम — Underweight
• 18.5 या उससे ज़्यादा, लेकिन 25 से कम — Normal
• 25 या उससे ज़्यादा, लेकिन 30 से कम — Overweight
• 30 या उससे ज़्यादा — Obese

सीमाएँ जान-बूझकर "से कम" (<) और "या उससे ज़्यादा" (>=) से लिखी गई हैं। "18.5 से 24.9" लिखें तो बीच में ख़ाली जगह रह जाती है — तब 24.95 जैसा BMI किसी भी श्रेणी में नहीं आता। < और >= से लिखें तो हर नंबर ठीक एक श्रेणी में आता है।

चार शर्तें:

1. BMI दशमलव के बाद एक अंक तक दिखाइए
2. शर्तें ऐसे क्रम में लिखिए कि चारों श्रेणियाँ सच में काम करें
3. लंबाई 0 दी जाए तो भाग देने से पहले ही रुककर एक मैसेज दीजिए — वरना ZeroDivisionError आएगा
4. चारों श्रेणियों के लिए चार अलग वैल्यू से चलाकर देखिए, और साथ में सीमा के ठीक ऊपर-नीचे वाली वैल्यू से भी — जैसे BMI ठीक 25 हो तो किस श्रेणी में आ रहा है (जवाब Overweight होना चाहिए)

चौथी शर्त ही सबसे ज़रूरी है। सीमा से बिल्कुल सटी वैल्यू पर ही शर्तों के क्रम की ग़लती पकड़ी जाती है।