Python Language
तुलना

वाक्य - विन्यास

• ! = - के बराबर नहीं है

• == - के बराबर है

• > - से अधिक

• < - से कम है

• >= - से अधिक या इसके बराबर

• <= - से कम या इसके बराबर

• is - यदि वस्तुएं समान वस्तु हैं तो परीक्षण करें

• यदि ऑब्जेक्ट ठीक एक ही वस्तु नहीं है तो परीक्षण नहीं है

पैरामीटर

से अधिक या उससे कम

x > y
x < y

ये ऑपरेटर दो प्रकार के मूल्यों की तुलना करते हैं, वे ऑपरेटरों की तुलना में कम और अधिक होते हैं। संख्याओं के लिए यह केवल संख्यात्मक मानों की तुलना करता है यह देखने के लिए कि कौन बड़ा है:

12 > 4
# True
12 < 4
# False
1 < 4
# True

तार के लिए वे लेक्सिकोग्राफिक रूप से तुलना करेंगे, जो वर्णानुक्रम के समान है लेकिन काफी समान नहीं है।

"alpha" < "beta"
# True
"gamma" > "beta"
# True
"gamma" < "OMEGA"
# False

इन तुलनाओं में, लोअरकेस अक्षर को 'अपरकेस' से बड़ा माना जाता है, यही कारण है कि "gamma" < "OMEGA" गलत है। यदि वे सभी बड़े होते तो यह अपेक्षित वर्णमाला क्रम परिणाम लौटा देता:

"GAMMA" < "OMEGA"
# True

प्रत्येक प्रकार परिभाषित करता है कि इसकी गणना < और > ऑपरेटरों के साथ अलग-अलग है, इसलिए आपको यह जांच करनी चाहिए कि इसका उपयोग करने से पहले ऑपरेटर किसी दिए गए प्रकार के साथ क्या मतलब रखते हैं।

बराबर नही है

x != y  

यह True अगर x और y बराबर नहीं हैं और अन्यथा False रिटर्न देता है।

12 != 1
# True
12 != '12'
# True
'12' != '12'
# False

के बराबर

x == y 

यदि x और y एक ही मूल्य हैं और बूलियन मान के रूप में परिणाम देता है तो यह अभिव्यक्ति मूल्यांकन करती है। आम तौर पर दोनों प्रकार और मूल्य का मिलान करने की आवश्यकता होती है, इसलिए इंट 12 स्ट्रिंग '12' के समान नहीं है।

12 == 12
# True
12 == 1
# False
'12' == '12'
# True
'spam' == 'spam'
# True
'spam' == 'spam '
# False
'12' == 12
# False

ध्यान दें कि प्रत्येक प्रकार को एक फ़ंक्शन को परिभाषित करना है जिसका उपयोग मूल्यांकन करने के लिए किया जाएगा यदि दो मान समान हैं। बिल्टइन प्रकारों के लिए ये फ़ंक्शन आपसे अपेक्षा के अनुसार व्यवहार करते हैं, और केवल समान मूल्य होने के आधार पर चीजों का मूल्यांकन करते हैं। हालाँकि, कस्टम प्रकार समानता परीक्षण को परिभाषित कर सकते हैं जो भी वे चाहें, जिसमें हमेशा True लौटना या हमेशा False लौटना शामिल है।

चेन तुलना

आप श्रृंखला तुलना के साथ कई तुलना ऑपरेटरों के साथ कई वस्तुओं की तुलना कर सकते हैं। उदाहरण के लिए

x > y > z

इसका संक्षिप्त रूप है:

x > y and y > z

यह केवल True मूल्यांकन करेगा, यदि दोनों तुलनाएं True ।

सामान्य रूप है

a OP b OP c OP d ...

जहां OP आपके द्वारा उपयोग किए जाने वाले कई तुलनात्मक कार्यों में से एक का प्रतिनिधित्व करता है, और पत्र मनमाने ढंग से मान्य अभिव्यक्तियों का प्रतिनिधित्व करते हैं।

ध्यान दें कि 0 != 1 != 0 True मूल्यांकन करता है, भले ही 0 != 0 False । आम गणितीय संकेतन के विपरीत जिसमें x != y != z अर्थ है कि x , y और z का अलग-अलग मान है। ज्यादातर मामलों में चैनिंग == संचालन का स्वाभाविक अर्थ है, क्योंकि समानता आमतौर पर सकर्मक होती है।

अंदाज

जब तक आपके पास उचित वाक्यविन्यास हो, तब तक आपके द्वारा उपयोग किए जाने वाले कितने आइटम और तुलना संचालन पर कोई सैद्धांतिक सीमा नहीं है:

1 > -1 < 2 > 0.5 < 100 != 24

यदि प्रत्येक तुलना True तो उपरोक्त रिटर्न True । हालाँकि, कन्वेक्टेड चाइनिंग का उपयोग करना अच्छी शैली नहीं है। एक अच्छी चेनिंग "दिशात्मक" होगी, इससे अधिक जटिल नहीं

1 > x > -4 > y != 8

दुष्प्रभाव

जैसे ही कोई तुलना False लौटाता है, अभिव्यक्ति तुरंत शेष सभी तुलनाओं को छोड़ते हुए False से मूल्यांकन करती है।

ध्यान दें कि a > exp > b में एक्सप्रेशन exp किया जाएगा, जबकि केवल एक बार

a > exp and exp > b

exp a > exp सच है अगर एक्स दो बार गणना की जाएगी।

`की तुलना` है `बनाम` == `

एक सामान्य नुकसान यह है कि समानता तुलना ऑपरेटरों is भ्रमित कर रही is और == ।

a == b a और b के मूल्य की तुलना करता है।

a is b की पहचान की तुलना करेंगे a और b ।

उदाहरण देकर स्पष्ट करने के लिए:

a = 'Python is fun!'
b = 'Python is fun!'
a == b # returns True
a is b # returns False

a = [1, 2, 3, 4, 5]
b = a      # b references a
a == b     # True
a is b     # True
b = a[:]   # b now references a copy of a
a == b     # True
a is b     # False [!!]

मूल रूप से, is के लिए के रूप में आशुलिपि के बारे में सोचा जा सकता है id(a) == id(b) ।

इससे परे, रन-टाइम के माहौल के झगड़े हैं जो चीजों को और जटिल करते हैं। लघु तार और छोटे पूर्णांक वापस आ जाएगी True जब तुलना में साथ is अजगर मशीन समान वस्तुओं के लिए कम स्मृति उपयोग करने का प्रयास के कारण,।

a = 'short'
b = 'short'
c = 5
d = 5
a is b # True
c is d # True

लेकिन लंबे तार और बड़े पूर्णांक अलग-अलग संग्रहीत किए जाएंगे।

a = 'not so short'
b = 'not so short'
c = 1000
d = 1000
a is b # False
c is d # False

आप का उपयोग करना चाहिए is के लिए परीक्षण करने के लिए None :

if myvar is not None:
    # not None
    pass
if myvar is None:
    # None
    pass

का एक प्रयोग is एक "प्रहरी" (यानी एक अनूठा वस्तु) के लिए परीक्षण करने के लिए है।

sentinel = object()
def myfunc(var=sentinel):
    if var is sentinel:
        # value wasn’t provided
        pass
    else:
        # value was provided
        pass

वस्तुओं की तुलना करना

कस्टम कक्षाओं की समानता की तुलना करने के लिए, आप __eq__ और __ne__ विधियों को परिभाषित करके == और != को ओवरराइड कर सकते हैं। आप __lt__ ( < ), __le__ ( <= ), __gt__ ( > ), और __ge__ ( > ) को भी ओवरराइड कर सकते हैं। ध्यान दें कि आपको केवल दो तुलना विधियों को ओवरराइड करने की आवश्यकता है, और पायथन बाकी को संभाल सकता है ( == है not < और not > , आदि)

class Foo(object):
    def __init__(self, item):
        self.my_item = item
    def __eq__(self, other):
        return self.my_item == other.my_item
    
a = Foo(5)
b = Foo(5)
a == b     # True
a != b     # False
a is b     # False

ध्यान दें कि यह सरल तुलना मानती है कि other (जिस वस्तु की तुलना की जा रही है) वही वस्तु प्रकार है। दूसरे प्रकार की तुलना में एक त्रुटि होगी:

class Bar(object):
    def __init__(self, item):
        self.other_item = item
    def __eq__(self, other):
        return self.other_item == other.other_item
    def __ne__(self, other):
        return self.other_item != other.other_item
    
c = Bar(5)
a == c    # throws AttributeError: 'Foo' object has no attribute 'other_item'

चेकिंग isinstance() या इसी तरह से इसे रोकने में मदद मिलेगी (यदि वांछित है)।

सामान्य गोत्र: अजगर टाइपिंग लागू नहीं करता है

कई अन्य भाषाओं में, यदि आप निम्नलिखित (जावा उदाहरण) चलाते हैं

if("asgdsrf" == 0) {
    //do stuff
}

... आपको एक त्रुटि मिलेगी। आप बस तार की तुलना पूर्णांक की तरह नहीं कर सकते। पाइथन में, यह पूरी तरह से कानूनी कथन है - यह केवल False को हल करेगा।

एक आम गोत्र निम्नलिखित है

myVariable = "1"
if 1 == myVariable:
    #do stuff

इस तुलना के लिए मूल्यांकन करेंगे False , हर बार एक त्रुटि के बिना, संभवतः एक बग छिपा या एक सशर्त तोड़ने।