True और False — सवाल पूछना सीखना

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

एक प्रोग्राम को कुछ तय करना है: क्या इस ऑर्डर पर छूट मिलेगी? क्या पासवर्ड काफ़ी लंबा है? क्या सामान स्टॉक में है?

फ़ैसला लेने वाला कोड अगले अध्याय (if) में आएगा। लेकिन उससे पहले वह चीज़ चाहिए जिस पर फ़ैसला टिकता है — एक सवाल, जिसका जवाब हाँ या ना हो। पायथन में इन जवाबों के नाम हैं True और False, और इस टाइप का नाम है bool।

आज हम सिर्फ़ सवाल पूछना सीखेंगे, फ़ैसला लेना नहीं। इसे अलग रखने की वजह है: if लिखते समय जो ग़लतियाँ होती हैं, उनमें से लगभग सब असल में सवाल ग़लत लिखने से होती हैं, if की बनावट से नहीं।

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

• छह तुलना ऑपरेटर इस्तेमाल करना
• = और == को अलग-अलग पहचानना
• and, or, not से छोटे सवाल जोड़कर बड़ा सवाल बनाना
• 18 <= age <= 60 जैसी चेन वाली तुलना लिखना
• बताना कि कौन-सी वैल्यू False न होते हुए भी पायथन की नज़र में झूठी (false) हैं

पहले यह आना चाहिए: अपने प्रोग्राम के यूज़र से इनपुट लेना।

छह तुलनाएँ

age = 22

print(age == 22)
print(age != 22)
print(age > 18)
print(age < 18)
print(age >= 22)
print(age <= 21)

True
False
True
False
True
False

हर तुलना का नतीजा एक वैल्यू है — True या False। यानी तुलना को वेरिएबल में स्टोर भी किया जा सकता है:

age = 22
is_adult = age >= 18
print(is_adult)
print(type(is_adult))

True
<class 'bool'>

ऐसे नाम देकर रखने से कोड पढ़ना बहुत आसान हो जाता है — is_adult पढ़ते ही समझ आ जाता है कि क्या जाँचा जा रहा है, जबकि age >= 18 देखकर पढ़ने वाले को एक बार सोचना पड़ता है।

= और == — एक निशान कम, मतलब पूरा अलग

total = 100          # an instruction: put 100 into total
print(total == 100)  # a question: is total 100?

True

• = रखता है (assignment)
• == पूछता है (comparison)

शर्त की जगह ग़लती से = लिख दें तो पायथन 3 सीधा एरर देता है, और मैसेज भी काम का होता है:

SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

अच्छी ख़बर — यह ग़लती चुपचाप नहीं रहती, पकड़ी जाती है।

स्ट्रिंग की तुलना

print("rafi" == "rafi")
print("Rafi" == "rafi")
print("apple" < "banana")
print(len("password123") >= 8)

True
False
True
True

दो बातों पर ध्यान दीजिए:

छोटे-बड़े अक्षर अलग हैं। "Rafi" और "rafi" बराबर नहीं हैं। इसलिए यूज़र की दी हुई स्ट्रिंग मिलाते समय पहले .strip().lower() चला लेना चाहिए — वरना जिसने नाम बड़े अक्षरों में या फ़ालतू स्पेस के साथ लिखा, वह छूट जाएगा:

typed = "  RAFI "
print(typed == "rafi")
print(typed.strip().lower() == "rafi")

False
True

स्ट्रिंग पर भी < काम करता है, और वह डिक्शनरी (शब्दकोश) की तरह अक्षरों के क्रम से चलता है — इसलिए "apple" < "banana"। नामों की लिस्ट को सॉर्ट करने का आधार यही है।

and, or, not

छोटे सवालों को जोड़कर बड़ा सवाल इन तीन शब्दों से बनता है:

age = 22
has_id = True

print(age >= 18 and has_id)
print(age >= 60 or has_id)
print(not has_id)

True
True
False

• and — दोनों सच हों तो सच
• or — कम से कम एक सच हो तो सच
• not — उलट देता है

पूरी तस्वीर एक साथ:

print(True and True)
print(True and False)
print(False and False)
print(True or False)
print(False or False)

True
False
False
True
False

or का मतलब है "एक या ज़्यादा", "सिर्फ़ एक" नहीं। बोलचाल में "चाय या कॉफ़ी?" कहें तो आमतौर पर एक ही समझा जाता है। पायथन के or में दोनों सच हों तब भी नतीजा True है। यह याद न रहे तो शर्त लिखते समय हैरानी होती है।

not हमेशा अपने ठीक बाद वाले हिस्से पर काम करता है, और सबसे पहले चलता है। क्रम यह है: पहले not, फिर and, और सबसे आख़िर में or।

print(True or False and False)
print((True or False) and False)

True
False

पहली लाइन में and पहले चला, इसलिए पायथन ने पढ़ा True or (False and False), यानी True or False — जो True है। दूसरी लाइन में ब्रैकेट ने क्रम बदल दिया। शक हो तो ब्रैकेट लगा दीजिए — जो बात गणित में सच है, वही यहाँ भी।

चेन वाली तुलना

कोई वैल्यू दो सीमाओं के बीच है या नहीं, यह देखने के लिए पायथन में गणित की तरह ही लिखा जा सकता है:

marks = 72

print(0 <= marks <= 100)
print(marks > 60 and marks < 80)
print(60 < marks < 80)

True
True
True

दूसरी और तीसरी लाइन एक ही बात कह रही हैं, लेकिन तीसरी पढ़ने में आसान है। कई प्रोग्रामिंग भाषाओं में ऐसे नहीं लिखा जा सकता; पायथन में लिखा जा सकता है, और इसे इस्तेमाल करना ही चाहिए।

कौन-सी वैल्यू पायथन की नज़र में झूठी हैं

सिर्फ़ False नहीं — कुछ आम वैल्यू को भी पायथन झूठा (false) मानता है:

print(bool(0))
print(bool(1))
print(bool(-5))
print(bool(""))
print(bool("hello"))
print(bool("0"))
print(bool("False"))

False
True
True
False
True
True
True

नियम एक लाइन में: शून्य और ख़ाली चीज़ें झूठी हैं, बाक़ी सब सच। इसलिए 0 झूठा, ख़ाली स्ट्रिंग "" झूठी; लेकिन -5 सच है (शून्य नहीं है), और "0" व "False" सच हैं — क्योंकि वे ख़ाली नहीं हैं, उनके अंदर अक्षर हैं।

आख़िरी दो लाइनें ही असली जाल हैं। input() से आने वाली हर चीज़ स्ट्रिंग है, इसलिए यूज़र 0 लिखे तब भी वह "0" है — और पायथन के लिए सच। नंबर की तुलना करनी हो तो पहले int() करना होगा।

इस "ख़ाली मतलब झूठा" नियम का एक काम का पहलू भी है — यूज़र कुछ लिखे बिना Enter दबा दे तो उसे पकड़ा जा सकता है:

name = input("Name: ").strip()
print("Name was given:", bool(name))

Name: 
Name was given: False

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

eligibility.py:

# Check a discount rule without deciding anything yet
age = int(input("Age            : "))
years_member = int(input("Years a member : "))
order_total = float(input("Order total    : "))

is_adult = age >= 18
is_senior = age >= 60
is_loyal = years_member >= 2
is_large_order = order_total >= 1000

# The rule: adults who are either long-standing members or spending a lot
gets_discount = is_adult and (is_loyal or is_large_order)

print()
print(f"Adult          : {is_adult}")
print(f"Senior         : {is_senior}")
print(f"Loyal member   : {is_loyal}")
print(f"Large order    : {is_large_order}")
print(f"Gets discount  : {gets_discount}")

Age            : 34
Years a member : 1
Order total    : 1500

Adult          : True
Senior         : False
Loyal member   : False
Large order    : True
Gets discount  : True

ध्यान दीजिए कि हर शर्त को पहले अलग नाम दिया गया, फिर उन्हें जोड़कर नियम लिखा गया। पूरी शर्त एक लाइन में लिखते — age >= 18 and (years_member >= 2 or order_total >= 1000) — तो कोड बिल्कुल वैसे ही चलता, लेकिन छह महीने बाद उसे पढ़कर नियम समझना मुश्किल होता। ब्रैकेट भी ज़रूरी है: वह न हो तो and पहले चल जाता और नियम ही बदल जाता।

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

SyntaxError: invalid syntax. Maybe you meant '==' ... तुलना की जगह = लिखा गया है। == लगाइए।

बराबर होना चाहिए था, लेकिन False आ रहा है तीन चीज़ें देखिए: फ़ालतू स्पेस (.strip()), छोटे-बड़े अक्षर (.lower()), और टाइप — "22" == 22 हमेशा False है, क्योंकि स्ट्रिंग और नंबर कभी बराबर नहीं होते।

TypeError: '<' not supported between instances of 'str' and 'int' आपने स्ट्रिंग की तुलना नंबर से की, शायद input() का नतीजा बदलना भूल गए। int() लगाइए।

दो दशमलव नंबर == से मेल नहीं खा रहे यह उम्मीद के मुताबिक़ है — अध्याय 5 का दशमलव वाला जाल याद कीजिए। round() करके तुलना कीजिए।

शर्त वह नहीं कर रही जो लिखा है and/or का क्रम देखिए। पहले not, फिर and, आख़िर में or। ब्रैकेट लगाकर अपना इरादा साफ़-साफ़ लिखिए।

आपकी बारी

password_check.py नाम की एक फ़ाइल लिखिए, जो एक पासवर्ड लेकर चार सवालों के जवाब True/False के रूप में प्रिंट करे:

1. लंबाई कम से कम 8 है
2. लंबाई 8 से 20 के बीच है (चेन वाली तुलना से लिखिए)
3. "password" शब्द इसके अंदर नहीं है (not और in दोनों चाहिए, और तुलना से पहले छोटे अक्षरों में बदल लीजिए)
4. ऊपर की तीनों बातें एक साथ सच हैं या नहीं

फिर कम से कम चार अलग पासवर्ड से चलाइए: एक बहुत छोटा, एक बहुत लंबा, एक जिसमें Password शब्द बड़े अक्षर से हो, और एक जो सारी शर्तें माने। चारों में जवाब सही आ रहा है या नहीं, मिलाकर देखिए — ख़ासकर तीसरे में, क्योंकि छोटे-बड़े अक्षरों वाला जाल वहीं छिपा है।