Python में Logical Operators: एक व्यावहारिक परिचय

प्रोग्रामिंग में हमें अक्सर कई शर्तों के आधार पर निर्णय लेने पड़ते हैं। उदाहरण के तौर पर, हम केवल तभी कोई क्रिया चलाना चाह सकते हैं जब कई शर्तें एक साथ पूरी हो रही हों। या वैकल्पिक रूप से, यदि कई शर्तों में से कोई भी एक पूरी हो जाए, तो कोई दूसरी क्रिया ट्रिगर करना चाह सकते हैं।

Python इन परिस्थितियों को संभालने के लिए कुछ logical operators प्रदान करता है – and, or, not।

इस ट्यूटोरियल में, हम समझेंगे कि Python के logical operators कैसे काम करते हैं और प्रोग्रामिंग तथा डेटा साइंस में उनका उपयोग कैसे किया जाता है। ध्यान दें कि हम अवधारणात्मक रूप से इन ऑपरेटर्स के लिए बड़े अक्षरों वाले शब्द AND, OR, और NOT का उपयोग करेंगे। और Python कीवर्ड्स का संदर्भ हम इस तरह देंगे: and, or, और not।

यदि आप एक क्यूरेटेड Python पाठ्यक्रम खोज रहे हैं, तो इस छह-कोर्स वाले Python Programming स्किल ट्रैक पर नज़र डालें।

विस्तार में जाने से पहले, जल्दी में रहने वालों के लिए बहुत संक्षिप्त उत्तर से शुरू करते हैं।

संक्षिप्त उत्तर: Python Logical Operators क्या हैं?

Python के logical operators (and, or, not) विशेष कीवर्ड हैं जो हमारे कोड में संयोजकों की तरह काम करते हैं, एक ही अभिव्यक्ति में कई शर्तों को जोड़ते और उनका मूल्यांकन करते हैं।

यह उदाहरण देखें:

temperature = 25
is_sunny = True
if temperature > 20 and is_sunny:
    print("It's a perfect day for a picnic!")
संचालित द्वारा

It's a perfect day for a picnic!
संचालित द्वारा

यहाँ, and ऑपरेटर सुनिश्चित करता है कि संदेश तभी प्रिंट हो जब दोनों शर्तें पूरी हों: तापमान 20 डिग्री से ऊपर हो और धूप हो।

अब or ऑपरेटर का एक और उदाहरण देखें:

has_umbrella = False

if is_sunny or has_umbrella:
    print("Let's go for a walk!")
संचालित द्वारा

Let's go for a walk!
संचालित द्वारा

इस स्थिति में, यदि या तो धूप है या हमारे पास छाता है, तो हम टहलने निकलेंगे।

अंत में, not ऑपरेटर किसी शर्त के truth value को उलट देता है:

if not is_sunny:
    print("Maybe we should stay indoors.")
संचालित द्वारा

यहाँ, संदेश तभी प्रिंट होता है जब धूप नहीं होती।

Logical operators हमें जटिल शर्तों को अभिव्यक्त करने का संक्षिप्त और शक्तिशाली तरीका देते हैं, जिससे हमारे प्रोग्राम कई कारकों के आधार पर निर्णय ले पाते हैं। अब, गहराई से समझते हैं और and logical ऑपरेटर से शुरुआत करते हैं।

Python: and ऑपरेटर

बूलियन लॉजिक में, AND ऑपरेशन दो मानों या अभिव्यक्तियों की तुलना करता है। परिणाम तभी true होता है जब दोनों मान true हों। यदि किसी एक या दोनों मानों का मान false है, तो AND ऑपरेशन का परिणाम false होता है। AND का व्यवहार संक्षेप में इस प्रकार है:

हम Python के and ऑपरेटर से यह truth table दोबारा बना सकते हैं:

options = True, False
for a in options:
    for b in options:
        print(f"{a} and {b} gives {a and b}")
संचालित द्वारा

True and True gives True
True and False gives False
False and True gives False
False and False gives False
संचालित द्वारा

options वेरिएबल में दो बूलियन मान हैं। नेस्टेड for लूप्स True और False के सभी क्रमचयों को बनाने के लिए दो बार इटरेट करते हैं।

अक्सर, and के साथ प्रयुक्त ऑपरेन्ड्स में comparison या equality ऑपरेटर्स शामिल होते हैं:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
   if len(name) < 5 and name[0] == "J":
      print(name)
संचालित द्वारा

Jane
संचालित द्वारा

नाम तभी प्रिंट होगा जब उसमें पाँच से कम अक्षर हों और वह "J" से शुरू होता हो। दोनों शर्तों का पूरा होना आवश्यक है।

Comparison और equality ऑपरेटर्स, जैसे < और ==, का मूल्यांकन True या False में होता है।

हालाँकि, Python का and ऑपरेटर केवल बूलियन True और False पर ही नहीं, किसी भी डेटा टाइप पर काम कर सकता है। आउटपुट मान भी किसी भी डेटा टाइप का हो सकता है।

इस सेक्शन में Python के and ऑपरेटर को विस्तार से समझते हैं। पहले, truthiness पर चर्चा करेंगे।

Python: truthy और falsy

हर Python ऑब्जेक्ट को बिल्ट-इन bool() से बूलियन टाइप में बदला जा सकता है। यदि bool(object) True लौटाता है, तो ऑब्जेक्ट truthy है। falsy ऑब्जेक्ट के लिए bool(object) False लौटाता है।

Python का and ऑपरेटर अपने ऑपरेन्ड्स की truthiness देखता है। यदि दोनों ऑपरेन्ड truthy हैं, तो and ऑपरेटर भी truthy मान लौटाता है। यदि एक या दोनों ऑपरेन्ड falsy हैं, तो and falsy लौटाता है। कुछ उदाहरण देखें:

if 42 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")संचालित द्वारा

Both operands are truthyसंचालित द्वारा

अब यह उदाहरण देखें:

if 42 and "":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")
संचालित द्वारा

One or both operands are falsyसंचालित द्वारा

और यह अंतिम उदाहरण देखें:

if 0 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")संचालित द्वारा

One or both operands are falsyसंचालित द्वारा

संख्यात्मक टाइप, जैसे integers और floats, non-zero होने पर truthy और zero होने पर falsy होते हैं। sequences, जैसे strings, खाली न होने पर truthy और खाली होने पर falsy होते हैं।

इसलिए, ऊपर दिए गए तीन उदाहरणों में केवल पहला उदाहरण उस शर्त को पूरा करता है जिसमें दोनों ऑपरेन्ड्स का truthy होना आवश्यक है ताकि and का मूल्यांकन truthy हो।

and ऑपरेटर हमेशा बूलियन मान नहीं लौटाता। and युक्त कोई अभिव्यक्ति सीधे किसी ऑपरेन्ड का मान भी लौटा सकती है। इसे और समझने के लिए वही उदाहरण सीधे evaluate करते हैं, if स्टेटमेंट में रखने के बजाय:

print(42 and "python")
print(42 and "")
print(0 and "python")
संचालित द्वारा

python

0संचालित द्वारा

क्या आप समझ पा रहे हैं कि यहाँ क्या हो रहा है?

तीसरे उदाहरण से शुरू करें, जिसमें दो ऑपरेन्ड 0 और "python" हैं। and ऑपरेटर दो truthy ऑपरेन्ड्स की तलाश करता है। चूँकि पहला ऑपरेन्ड 0 है, यह falsy है। पूरे अभिव्यक्ति का परिणाम दूसरे ऑपरेन्ड के मान से स्वतंत्र रूप से falsy ही रहेगा, इसलिए प्रोग्राम को दूसरे ऑपरेन्ड की जाँच करने की जरूरत नहीं।

हालाँकि, and ऑपरेटर False नहीं लौटाता। यह सीधे पहला ऑपरेन्ड लौटाता है। चूँकि पहला ऑपरेन्ड falsy है, पूरी and अभिव्यक्ति का मूल्यांकन falsy होता है। Python में यह समस्या नहीं पैदा करता, क्योंकि जहाँ true या false की आवश्यकता होती है, वहाँ Python किसी ऑब्जेक्ट की truthiness का उपयोग कर सकता है।

पहले उदाहरण में, पहला ऑपरेन्ड 42 है, जो truthy है। प्रोग्राम दूसरे ऑपरेन्ड का मूल्यांकन कर उसे लौटाता है। दूसरा ऑपरेन्ड स्ट्रिंग "python" है, जो truthy है, इसलिए पूरी अभिव्यक्ति truthy रहती है।

दूसरे उदाहरण में, पहला ऑपरेन्ड भी 42 है। यह truthy है, इसलिए प्रोग्राम दूसरा ऑपरेन्ड evaluate करके वही लौटाता है, जो कि खाली स्ट्रिंग है। खाली स्ट्रिंग falsy होती है, अतः पूरी and अभिव्यक्ति falsy हो जाती है।

जब पहला ऑपरेन्ड truthy हो, तो and ऑपरेटर हमेशा दूसरे ऑपरेन्ड का मान लौटाता है, चाहे दूसरा ऑपरेन्ड truthy हो या falsy।

जब पहला ऑपरेन्ड falsy हो, तो Python दूसरे ऑपरेन्ड का मूल्यांकन नहीं करता। इसे short-circuiting कहते हैं, और यह lazy evaluation का एक रूप है। आप इसे निम्न कोड से देख सकते हैं:

0 and 5/0
संचालित द्वारा

0
संचालित द्वारा

दूसरा ऑपरेन्ड 5/0 है, जो सामान्यतः ZeroDivisionError उठाएगा। लेकिन इस उदाहरण में पहला ऑपरेन्ड falsy होने के कारण 5/0 अभिव्यक्ति evaluate ही नहीं होती। अपवाद कभी उठता ही नहीं।

उदाहरण: प्रोग्रामर्स की ऑनलाइन स्टोर

एक सरल उदाहरण पर विचार करें जो वास्तविक जीवन के अनुप्रयोग का प्रतिनिधित्व करता है। प्रोग्रामर्स के लिए सामान बेचने वाली एक ऑनलाइन स्टोर में लेन-देन API के जरिए रिकॉर्ड और एक्सेस किए जाते हैं। डेटा को डिक्शनरी की सूची में बदला जाता है। सूची का हर आइटम एक लेन-देन को दर्शाता है और हर लेन-देन में संबंधित जानकारी वाली एक डिक्शनरी होती है:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
संचालित द्वारा

प्रत्येक लेन-देन में आइटम का नाम और कीमत, ऑर्डर में शामिल मात्रा, और लेन-देन सफल रहा या नहीं—यह जानकारी शामिल होती है।

मान लें हमें ऐसे सफल लेन-देन चाहिए जिनके आइटम की कीमत $100 या उससे अधिक हो। हम आवश्यक पंक्तियों को फ़िल्टर करने के लिए and ऑपरेटर का उपयोग कर सकते हैं:

for item in data:
    if item["Success"] and item["Price"] >= 100:
        print(item)संचालित द्वारा

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}संचालित द्वारा

इस कोड का आउटपुट केवल वही लेन-देन दिखाता है जो दोनों शर्तों को पूरा करता है। लेन-देन की सूची के प्रत्येक आइटम के लिए, if स्टेटमेंट दो अभिव्यक्तियों की truthiness जाँचता है:

• प्रत्येक डिक्शनरी में "Success" कुंजी के साथ जुड़े मान True या False होते हैं।
• item["Price"] >= 100 में greater than or equal to ऑपरेटर भी True या False लौटाता है।

Python किताब और केबल्स कीमत की शर्त पूरी नहीं करते क्योंकि वे $100 से कम हैं। कॉफी मशीन इस सीमा से ऊपर है, लेकिन वह लेन-देन सफल नहीं था, इसलिए प्रिंटआउट में शामिल नहीं है।

हम इस ऑनलाइन स्टोर के उदाहरण पर इस ट्यूटोरियल में आगे फिर लौटेंगे।

अगले सेक्शन में, हम or ऑपरेटर पर ध्यान देंगे।

Python: or ऑपरेटर

बूलियन लॉजिक में OR logical ऑपरेटर को दो ऑपरेन्ड्स की जरूरत होती है। यदि कम से कम एक ऑपरेन्ड true है, तो परिणाम true होता है:

हम Python के or ऑपरेटर का उपयोग करके यह truth table फिर बना सकते हैं:

options = True, False
for a in options:
    for b in options:
        print(f"{a} or {b} gives {a or b}")
संचालित द्वारा

True or True gives True
True or False gives True
False or True gives True
False or False gives False
संचालित द्वारा

हम पहले वाले नामों के उदाहरण को फिर देख सकते हैं, लेकिन इस बार and की जगह or का उपयोग करेंगे:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
    if len(name) < 5 or name[0] == "J":
        print(name)
संचालित द्वारा

James
Bob
Jane
Kate
Mary
संचालित द्वारा

अब if स्टेटमेंट में or अभिव्यक्ति है। अतः for लूप वे सभी नाम प्रिंट करता है जिनमें या तो पाँच से कम अक्षर हैं या जो "J" से शुरू होते हैं। स्ट्रिंग "Jane" दोनों शर्तों को पूरा करती है। बाकी प्रिंट हुए नामों में से प्रत्येक एक शर्त पूरी करता है।

Python or ऑपरेटर: truthy और falsy

or ऑपरेटर भी truthy और falsy मानों को देखता है, केवल बूलियन True और False को नहीं। कुछ उदाहरण देखें:

if 42 or [10, 20, 30]:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
संचालित द्वारा

At least one operand is truthy
संचालित द्वारा

अब यह उदाहरण देखें:

if 42 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
संचालित द्वारा

At least one operand is truthyसंचालित द्वारा

और यह अंतिम उदाहरण देखें:

if 0 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")
संचालित द्वारा

None of the operands is truthy
संचालित द्वारा

पहले उदाहरण में, integer 42 और non-empty list [10, 20, 30] truthy हैं। or को कम से कम एक truthy ऑपरेन्ड चाहिए होता है, इसलिए पूरी अभिव्यक्ति truthy होती है।

दूसरे उदाहरण में, 42 truthy है लेकिन खाली सूची [] falsy है क्योंकि वह खाली sequence है। चूँकि दो में से एक ऑपरेन्ड truthy है, पूरी or अभिव्यक्ति truthy होती है।

अंतिम उदाहरण में, 0 और [] दोनों falsy हैं। इसलिए पूरी अभिव्यक्ति falsy होती है।

or ऑपरेटर भी अनावश्यक मूल्यांकन से बचने के लिए अभिव्यक्ति का मूल्यांकन करते समय short-circuiting का इस्तेमाल करता है। इसे दर्शाने के लिए कुछ उदाहरण देखें:

print(42 or [10, 20, 30])
print(42 or [])
print([] or 42)
print([] or 0)
संचालित द्वारा

42
42
42
0
संचालित द्वारा

पहले उदाहरण में, पहला ऑपरेन्ड 42 है, जो truthy है। चूँकि or को पूरे अभिव्यक्ति की truthiness तय करने के लिए केवल एक truthy ऑपरेन्ड चाहिए, इसलिए पहला ऑपरेन्ड तुरंत लौटा दिया जाता है। दूसरे ऑपरेन्ड का मूल्यांकन नहीं होता क्योंकि उसका मान अंतिम परिणाम को प्रभावित नहीं करेगा। or ऑपरेटर पहला ऑपरेन्ड 42 लौटाता है, न कि बूलियन True। Python में, किसी भी truthy मान का प्रभाव if तथा while स्टेटमेंट जैसी स्थितियों में बूलियन True जैसा ही होता है।

दूसरे उदाहरण में भी पहला ऑपरेन्ड 42 है, और अभिव्यक्ति उसी integer को लौटाती है, भले ही दूसरा ऑपरेन्ड falsy हो।

तीसरे और चौथे उदाहरण में, पहला ऑपरेन्ड खाली सूची है, जो falsy है। इसलिए दोनों ही मामलों में दूसरा ऑपरेन्ड लौटाया जाता है।

उदाहरण: प्रोग्रामर्स की ऑनलाइन स्टोर

आइए प्रोग्रामर्स को सामान बेचने वाली ऑनलाइन स्टोर के लेन-देन पर फिर लौटें। यहाँ वे चार नमूना लेन-देन हैं जिनका हम उपयोग कर रहे हैं:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
संचालित द्वारा

आपको ग्राहक व्यवहार की और जाँच के लिए कुछ लेन-देन पहचानने हैं। आप वे लेन-देन ढूँढना चाहते हैं जो या तो असफल रहे हों या जिनमें $75 से कम कीमत वाला आइटम शामिल हो। क्योंकि आपके पास दो शर्तें हैं और आपको कम से कम एक शर्त पूरी होना पर्याप्त है, आप or ऑपरेटर का उपयोग कर सकते हैं:

for item in data:
    if item["Success"] == False or item["Price"] < 75:
        print(item)
संचालित द्वारा

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
संचालित द्वारा

यह for लूप वे पंक्तियाँ दिखाता है जो कम से कम एक शर्त से मेल खाती हैं। Python किताब और केबल्स शामिल हैं क्योंकि उनकी कीमत $75 से कम है। कॉफी मशीन शामिल है क्योंकि वह लेन-देन असफल रहा था।

असफल लेन-देन को फ़िल्टर करने का एक वैकल्पिक तरीका भी है, जिसे हम अगले सेक्शन में देखेंगे।

Python: not ऑपरेटर

NOT ऑपरेटर AND और OR से अलग है क्योंकि इसे केवल एक ऑपरेन्ड चाहिए। NOT true को false में और false को true में बदल देता है। NOT के लिए truth table यह है:

इसे हम Python के not ऑपरेटर से दोहरा सकते हैं:

options = True, False
    for a in options:
        print(f"not {a} evaluates to {not a}")
संचालित द्वारा

not True evaluates to False
not False evaluates to True
संचालित द्वारा

Python not ऑपरेटर: truthy और falsy

and और or की तरह, not के साथ इस्तेमाल होने वाला ऑपरेन्ड भी बूलियन होना जरूरी नहीं है। चूँकि हर ऑब्जेक्ट या तो truthy होता है या falsy, कोई भी ऑब्जेक्ट not के साथ इस्तेमाल किया जा सकता है।

if not "python":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")
संचालित द्वारा

The `if` statement evaluated as `False`संचालित द्वारा

यह उदाहरण भी देखें:

if not "":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")
संचालित द्वारा

The `if` statement evaluated as `True`
संचालित द्वारा

Truthy मान not ऑपरेटर के साथ False में बदल जाते हैं और falsy मान True में।

and और or के विपरीत, not ऑपरेटर हमेशा एक बूलियन ऑब्जेक्ट लौटाता है:

print(not "python")
print(not "")
संचालित द्वारा

False
True
संचालित द्वारा

उदाहरण: प्रोग्रामर्स की ऑनलाइन स्टोर

पिछले सेक्शनों में, हमने ऑनलाइन स्टोर के लेन-देन का उपयोग किया था। इस उदाहरण में हम सभी असफल लेन-देन दिखाना चाहते हैं। एक तरीका यह है कि equality ऑपरेटर == से जाँचें कि data["Success"] False के बराबर है या नहीं। हालाँकि, हम not ऑपरेटर भी उपयोग कर सकते हैं:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
for item in data:
    if not item["Success"]:
        print(item)
संचालित द्वारा

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
संचालित द्वारा

चूँकि असफल लेन-देन के लिए item["Success"] का मान False होता है, इसलिए not item["Success"] True लौटाता है। अतः for लूप असफल लेन-देन प्रिंट करता है:

अगले सेक्शन में, हम सीखेंगे कि एक ही अभिव्यक्ति में कई logical ऑपरेटर्स को कैसे संयोजित किया जाता है।

Python: Operator Precedence

अब तक के उदाहरणों में, हमने प्रत्येक बार केवल एक logical ऑपरेटर का उपयोग किया। इस सेक्शन में, देखते हैं कि जब हम एक ही अभिव्यक्ति में अधिक logical ऑपरेटर्स को मिलाते हैं तो क्या होता है।

Python: and की precedence or से अधिक होती है

हम पहले उपयोग किए गए ऑनलाइन स्टोर के लेन-देन पर काम जारी रखते हैं। यह सशर्त स्टेटमेंट आज़माएँ:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
​
for item in data:
    if item["Price"] > 100 or item["Quantity"] > 2 and item["Success"]:
        print(item)
संचालित द्वारा

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
संचालित द्वारा

if स्टेटमेंट में दो logical ऑपरेटर्स हैं। यह देखने से पहले कि Python इस अभिव्यक्ति को कैसे सँभालता है, if स्टेटमेंट का एक अंग्रेज़ी कथन देखें: यदि आइटम की कीमत $100 से अधिक है या बिकी हुई मात्रा दो से अधिक है और बिक्री सफल रही थी, तो आइटम प्रिंट करें।

यह वाक्य अतिरिक्त विराम चिह्नों के बिना अस्पष्ट है और अधिक कॉमा जोड़ने पर भी भ्रमित कर सकता है। उदाहरण के लिए, क्या कॉफी मशीन वाला लेन-देन शामिल होना चाहिए? आइटम की कीमत आवश्यक सीमा से ऊपर है, लेकिन लेन-देन सफल नहीं था।

Python इस अस्पष्टता को and ऑपरेटर को or ऑपरेटर पर precedence देकर सुलझाता है। यानी पहले and अभिव्यक्ति का मूल्यांकन होता है, और उसका परिणाम or अभिव्यक्ति में उपयोग होता है।

इसलिए, पहले item["Quantity"] > 2 and item["Success"] अभिव्यक्ति evaluate होती है। यह अभिव्यक्ति केवल केबल्स वाले लेन-देन के लिए truthy मान लौटाती है। शेष आइटम्स के लिए यह falsy रहती है।

इसके बाद and अभिव्यक्ति का मान or ऑपरेटर के साथ उपयोग होता है। or अभिव्यक्ति उनके लिए truthy लौटाती है जहाँ and अभिव्यक्ति truthy हो—यह केवल केबल्स वाला लेन-देन था—और उन आइटम्स के लिए जिनकी कीमत $100 से अधिक है। सीमा से ऊपर कीमत वाले दो आइटम हैं: कॉफी मशीन और हेडफोन्स।

Python: कोष्ठक (parentheses) और logical ऑपरेटर्स

लेकिन यदि हमें वे लेन-देन चाहिए जिनमें आइटम की कीमत $100 से अधिक हो या मात्रा दो से अधिक हो, और साथ ही हम यह भी सुनिश्चित करना चाहते हैं कि लेन-देन सफल रहा हो? इस स्थिति में, हम चाहते हैं कि or अभिव्यक्ति को and पर precedence मिले ताकि उसका मूल्यांकन पहले हो। यह हम or अभिव्यक्ति के चारों ओर कोष्ठक लगाकर कर सकते हैं:

for item in data:
    if (item["Price"] > 100 or item["Quantity"] > 2) and item["Success"]:
        print(item)
संचालित द्वारा

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
संचालित द्वारा

अतिरिक्त कोष्ठक or अभिव्यक्ति को precedence देते हैं। कॉफी मशीन वाला लेन-देन अब शामिल नहीं है क्योंकि वह दूसरे and ऑपरेन्ड के लिए falsy है।

Python: not की precedence and और or से अधिक होती है

not ऑपरेटर को and और or पर precedence मिलती है। इसलिए, not का मूल्यांकन बाकी दोनों logical ऑपरेटर्स से पहले होता है।

निम्नलिखित if स्टेटमेंट पर विचार करें, जिसमें not और and दोनों शामिल हैं:

for item in data:
    if not item["Success"] and item["Price"] > 100:
        print(item)
संचालित द्वारा

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
संचालित द्वारा

चूँकि पहले not evaluate होता है, यह अभिव्यक्ति पहले item["Success"] पर not ऑपरेटर लागू करेगी। not अभिव्यक्ति से प्राप्त मान and अभिव्यक्ति में पहले ऑपरेन्ड के रूप में उपयोग होता है। केवल कॉफी मशीन वाली एंट्री इस शर्त को पूरा करती है—यही एकमात्र लेन-देन है जो असफल रहा और जिसकी कीमत $100 से अधिक है।

हालाँकि, हम कोष्ठकों का उपयोग कर and ऑपरेटर को precedence दे सकते हैं:

for item in data:
    if not (item["Success"] and item["Price"] > 100):
        print(item)
संचालित द्वारा

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}
संचालित द्वारा

इस मामले में, पहले and अभिव्यक्ति evaluate होती है। केवल हेडफोन्स वाली एंट्री True देती है क्योंकि वही एक सफल लेन-देन है जिसकी कीमत $100 से अधिक है। लेकिन हमने कोष्ठकों में अभिव्यक्ति से पहले not जोड़ा है। इसलिए, कोड शेष तीन लेन-देन प्रिंट करता है।

आम तौर पर, यदि किसी अभिव्यक्ति में बहुत सारे ऑपरेटर्स होने के कारण वह बहुत जटिल हो जाए, तो पठनीयता बढ़ाने के लिए उसे विभाजित करना बेहतर रहता है।

निष्कर्ष

Python के logical operators and, or, और not का व्यापक रूप से प्रोग्रामिंग और डेटा साइंस के अनेक अनुप्रयोगों में उपयोग होता है। ये ऑपरेटर्स लॉजिक और गणित में व्यापक रूप से प्रयुक्त AND, OR, और NOT बूलियन लॉजिकल ऑपरेटर्स के व्यवहार को दोहराते हैं।

हालाँकि, Python ऑपरेटर्स केवल बूलियन मान ही नहीं, बल्कि किसी भी ऑब्जेक्ट को स्वीकार कर सकते हैं। and और or ऑपरेटर्स short-circuit मूल्यांकन का उपयोग करते हैं और आउटपुट में अपने ऑपरेन्ड्स में से किसी एक को लौटाते हैं।

Python के logical operators डेटा को फ़िल्टर करने, डेटा सेट्स में फीचर्स पहचानने, और प्रोग्राम के प्रवाह को नियंत्रित करने के लिए जटिल नियम बनाने के प्रमुख औज़ार हैं। यदि आप इसके बारे में और सीखना चाहते हैं, तो यह नौ-कोर्स वाला Data Analyst With Python करियर ट्रैक देखें।