मैं IF सशर्त में त्रुटि प्राप्त कर रहा हूं। मैं क्या गलत कर रहा हूं?
वहाँ कारण है कि आपको लगता SyntaxErrorहै कि &&पायथन में कोई ऑपरेटर नहीं है । इसी तरह ||और मान्य पायथन ऑपरेटर नहीं! हैं ।
कुछ संचालक जिन्हें आप अन्य भाषाओं से जानते हैं, उनमें पायथन में एक अलग नाम है। तार्किक ऑपरेटरों &&और ||वास्तव में कहा जाता है andऔर or। इसी तरह तार्किक निषेध ऑपरेटर !को कहा जाता है not।
तो आप बस लिख सकते हैं:
if len(a) % 2 == 0 and len(b) % 2 == 0:
या और भी:
if not (len(a) % 2 or len(b) % 2):
कुछ अतिरिक्त जानकारी (जो काम में आ सकती है):
मैंने इस तालिका में ऑपरेटर "समकक्ष" को संक्षेप में प्रस्तुत किया है:
+------------------------------+---------------------+
| Operator (other languages) | Operator (Python) |
+==============================+=====================+
| && | and |
+------------------------------+---------------------+
| || | or |
+------------------------------+---------------------+
| ! | not |
+------------------------------+---------------------+
पायथन प्रलेखन भी देखें : 6.11। बूलियन ऑपरेशन ।
तार्किक संचालकों के अलावा पायथन के पास बिटवाइज़ / बाइनरी ऑपरेटर भी हैं:
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
पाइथन में कोई बिटवाइज़ निगेटिव नहीं है (बस बिटवाइज़ उलटा ऑपरेटर है ~- लेकिन यह बराबर नहीं है not)।
6.6 भी देखें । यूनिरी अंकगणित और बिटवाइज़ / बाइनरी ऑपरेशन और 6.7। बाइनरी अंकगणितीय संचालन ।
लॉजिकल ऑपरेटर्स (कई अन्य भाषाओं की तरह) में यह फायदा है कि ये शॉर्ट-सर्कुलेटेड होते हैं। इसका मतलब है कि यदि पहले ऑपरेंड पहले से ही परिणाम को परिभाषित करता है, तो दूसरे ऑपरेटर का मूल्यांकन बिल्कुल नहीं किया जाता है।
यह दिखाने के लिए मैं एक फ़ंक्शन का उपयोग करता हूं जो बस एक मूल्य लेता है, इसे प्रिंट करता है और इसे फिर से लौटाता है। यह देखना आसान है कि प्रिंट स्टेटमेंट के कारण वास्तव में क्या मूल्यांकन किया गया है:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
जैसा कि आप देख सकते हैं कि केवल एक प्रिंट स्टेटमेंट निष्पादित किया जाता है, इसलिए पायथन वास्तव में सही ऑपरेंड पर भी नहीं दिखता है।
बाइनरी ऑपरेटरों के लिए यह मामला नहीं है। वे हमेशा दोनों ऑपरेंड का मूल्यांकन करते हैं:
>>> res = print_and_return(False) & print_and_return(True);
False
True
लेकिन अगर पहला ऑपरेंड पर्याप्त नहीं है, तो निश्चित रूप से, दूसरे ऑपरेटर का मूल्यांकन किया जाता है:
>>> res = print_and_return(True) and print_and_return(False);
True
False
इसे सारांशित करने के लिए यहां एक और तालिका दी गई है:
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
Trueऔर Falseप्रतिनिधित्व करते हैं क्या bool(left-hand-side), वे होने की जरूरत नहीं है रिटर्न Trueया Falseवे सिर्फ वापस जाने के लिए की जरूरत है, Trueया Falseजब boolउन्हें (1) पर कहा जाता है।
तो Pseudo-Code (!) andऔर orफ़ंक्शंस इन जैसे काम करते हैं:
def and(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return evaluate(expr2)
else:
return left
def or(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return left
else:
return evaluate(expr2)
ध्यान दें कि यह छद्म कोड है न कि पायथन कोड। पाइथन में आप कॉल किए गए फ़ंक्शंस नहीं बना सकते andया orक्योंकि ये कीवर्ड हैं। इसके अलावा, आपको "मूल्यांकन" या कभी भी उपयोग नहीं करना चाहिए if bool(...)।
अपने स्वयं के वर्गों के व्यवहार को अनुकूलित करना
इस अंतर्निहित boolकॉल का उपयोग यह अनुकूलित करने के लिए किया जा सकता है कि आपकी कक्षाएं कैसे व्यवहार करती हैं and, orऔर not।
यह दिखाने के लिए कि यह कैसे अनुकूलित किया जा सकता है मैं इस वर्ग का उपयोग करता हूं जो फिर से printकुछ ट्रैक करता है कि क्या हो रहा है:
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
print('__bool__ called on {!r}'.format(self))
return bool(self.value)
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
तो आइए देखें कि इन ऑपरेटरों के साथ संयोजन में उस वर्ग के साथ क्या होता है:
>>> if Test(True) and Test(False):
... pass
__bool__ called on Test(True)
__bool__ called on Test(False)
>>> if Test(False) or Test(False):
... pass
__bool__ called on Test(False)
__bool__ called on Test(False)
>>> if not Test(True):
... pass
__bool__ called on Test(True)
यदि आपके पास कोई __bool__विधि नहीं है, तो पायथन यह भी जाँचता है कि क्या वस्तु में कोई __len__विधि है और यदि यह शून्य से अधिक मान देता है। यदि आप एक अनुक्रम कंटेनर बनाते हैं, तो यह जानना उपयोगी हो सकता है।
4.1 भी देखें । सत्य मूल्य परीक्षण ।
NumPy सरणियाँ और उपवर्ग
संभवतः मूल प्रश्न के दायरे से थोड़ा परे लेकिन अगर आप NumPy सरणियों या उपवर्गों (जैसे पंडास सीरीज या डेटाफ़्रेम) के साथ काम कर रहे हैं, तो अंतर्निहित boolकॉल खतरनाक हो जाएगी ValueError:
>>> import numpy as np
>>> arr = np.array([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> arr and arr
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> import pandas as pd
>>> s = pd.Series([1,2,3])
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> s and s
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
इन मामलों में आप NumPy से तार्किक और फ़ंक्शन का उपयोग कर सकते हैं जो एक तत्व-वार and(या or) करता है:
>>> np.logical_and(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([False, False, True, False])
>>> np.logical_or(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([ True, False, True, True])
यदि आप बूलियन सरणियों के साथ काम कर रहे हैं, तो आप भी बाइनरी ऑपरेटरों का उपयोग कर सकते हैं NumPy के साथ, ये तत्व-वार (लेकिन बाइनरी भी) तुलना करते हैं:
>>> np.array([False,False,True,True]) & np.array([True, False, True, False])
array([False, False, True, False])
>>> np.array([False,False,True,True]) | np.array([True, False, True, False])
array([ True, False, True, True])
(1)
कि boolऑपरेंड पर कॉल को वापस लौटना है Trueया Falseपूरी तरह से सही नहीं है। यह सिर्फ पहला ऑपरेंड है जो इसे __bool__विधि में एक बूलियन वापस करने की आवश्यकता है :
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
return self.value
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
>>> x = Test(10) and Test(10)
TypeError: __bool__ should return bool, returned int
>>> x1 = Test(True) and Test(10)
>>> x2 = Test(False) and Test(10)
ऐसा इसलिए है क्योंकि andवास्तव में पहला ऑपरेंड वापस आता है अगर पहला ऑपरेंड मूल्यांकन करता है Falseऔर अगर यह मूल्यांकन करता है Trueतो यह दूसरा ऑपरेंड लौटाता है:
>>> x1
Test(10)
>>> x2
Test(False)
इसी तरह के लिए orलेकिन बस के आसपास अन्य तरीके:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
हालांकि यदि आप उन्हें एक ifबयान में उपयोग करते हैं, तो परिणाम पर ifभी स्पष्ट रूप से कॉल करेगा bool। तो ये महीन बिंदु आपके लिए प्रासंगिक नहीं हो सकते हैं।