Black Jack

तुलना

Python निम्नलिखित बुनियादी तुलना ऑपरेटरों को सपोर्ट करता है:

इन सभी की प्राथमिकता एक जैसी होती है (जो बूलियन ऑपरेशन की प्राथमिकता से ऊँची है, लेकिन अंकगणितीय या बिटवाइज़ ऑपरेशन की प्राथमिकता से नीची)।

अलग-अलग डेटा टाइप के बीच तुलना

अलग-अलग टाइप के ऑब्जेक्ट (संख्यात्मक टाइप को छोड़कर) डिफ़ॉल्ट रूप से कभी बराबर नहीं माने जाते। किसी class के भिन्न इंस्टेंस भी बराबर नहीं माने जाते, जब तक कि वह class ऐसे विशेष रिच कम्पैरिज़न मेथड परिभाषित न करे जो object की डिफ़ॉल्ट तुलना का व्यवहार बदल दें। rich comparisons के ज़रिए व्यवहार बदलना आगे के किसी अभ्यास में सिखाया जाएगा। इस विषय पर (बहुत) अधिक जानकारी के लिए Python के डॉक्युमेंटेशन में वैल्यू की तुलना देखिए।

संख्यात्मक टाइप इस टाइप-मिलान नियम के (मुख्यतः) अपवाद हैं। एक integer को float के बराबर माना जा सकता है (या एक octal को hexadecimal के बराबर), बशर्ते तुलना के लिए इनका अंतर्निहित रूपांतरण संभव हो।

Python की स्टैंडर्ड लाइब्रेरी के बाकी संख्यात्मक टाइप (complex, decimal, fractions) के लिए तुलना के ऑपरेटर वहाँ परिभाषित हैं जहाँ वे "समझ में आते हैं" (यानी जहाँ अंतर्निहित रूपांतरण से नतीजा नहीं बदलता), लेकिन अगर तुलना के लिए मूल ऑब्जेक्ट ठीक-ठीक रूपांतरित न हो सकें तो वे TypeError फेंकते हैं। numeric conversion के लिए python जो नियम इस्तेमाल करता है, उनके बारे में अधिक जानकारी के लिए Python के डॉक्युमेंटेशन में अंकगणितीय रूपांतरण देखिए।

>>> import fractions

# A string cannot be converted to an int.
>>> 17 == '17'
False

# An int can be converted to float for comparison.
>>> 17 == 17.0
True

# The fraction 6/3 can be converted to the int 2
# The int 2 can be converted to 0b10 in binary.
>>> 6/3 == 0b10
True

# An int can be converted to a complex number with a 0 imaginary part.
>>> 17 == complex(17)
True

# The fraction 2/5 can be converted to the float 0.4
>>> 0.4 == 2/5
True

>>> complex(2/5, 1/2) == complex(0.4, 0.5)
True

किसी संख्या की NaN (संख्या नहीं) टाइप से कोई भी क्रम-तुलना False देती है। Python में NaN की परिभाषा का एक उलझाने वाला नतीजा यह है कि NaN कभी NaN के बराबर नहीं होता।

>>> x = float('NaN')

>>> 3 < x
False

>>> x < 3
False

# NaN never compares equal to NaN
>>> x == x
False

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

संख्याओं के विपरीत, स्ट्रिंग (str) की तुलना शब्दकोशीय क्रम में होती है, और इसके लिए उनके अलग-अलग Unicode कोड पॉइंट काम में लिए जाते हैं (यानी str के हर कोड पॉइंट को बिल्ट-इन फंक्शन ord() में पास करने पर जो int मिलता है, वही)। अगर दोनों स्ट्रिंग के सारे कोड पॉइंट मेल खाएँ और एक ही क्रम में हों, तो दोनों स्ट्रिंग बराबर मानी जाती हैं। यह तुलना 'जोड़ी-दर-जोड़ी' होती है: पहला पहले से, दूसरा दूसरे से, वगैरह। Python 3.x में str और bytes को सीधे न बदला जा सकता है, न उनकी तुलना की जा सकती है।

>>> 'Python' > 'Rust'
False

>>> 'Python' > 'JavaScript'
True

# Examples with Mandarin.
# hello < goodbye
>>> '你好' < '再见'
True

# ord() of first characters
>>> ord('你'), ord('再')
(20320, 20877)

# ord() of second characters
>>> ord('好'), ord('见')
(22909, 35265)

# And with Korean words.
# Pretty < beautiful.
>>> '예쁜' < '아름다운'
False

>>> ord('예'), ord('아')
(50696, 50500)

तुलना की शृंखला

तुलना के ऑपरेटरों की शृंखला मनमाने ढंग से बनाई जा सकती है, यानी इन्हें किसी भी लंबाई के किसी भी संयोजन में इस्तेमाल किया जा सकता है। ध्यान दीजिए कि किसी एक्सप्रेशन का मूल्यांकन left से right की ओर होता है।

उदाहरण के लिए, x < y <= z और x < y and y <= z बराबर हैं, बस इसमें y का मूल्यांकन सिर्फ़ एक बार होता है। दोनों ही सूरतों में, जब x < y को False पाया जाता है, तब z का मूल्यांकन बिल्कुल भी नहीं होता। इसे अक्सर short-circuit evaluation कहा जाता है, यानी अगर एक्सप्रेशन का सत्य मान पहले ही तय हो चुका हो, तो मूल्यांकन वहीं रुक जाता है।

Short circuiting को कई बूलियन ऑपरेटर, फंक्शन, और Python में तुलना की शृंखला भी सपोर्ट करती है। C, C++, C# और Java समेत कई दूसरी प्रोग्रामिंग भाषाओं के विपरीत, Python में a < b < c जैसे जुड़े एक्सप्रेशन का पारंपरिक गणितीय अर्थ और प्राथमिकता होती है।

>>> x = 2
>>> y = 5
>>> z = 10

>>> x < y < z
True

>>> x < y > z
False

>>> x > y < z
False

ऑब्जेक्ट की पहचान की तुलना

ऑपरेटर is और is not ऑब्जेक्ट के मान के बजाय ऑब्जेक्ट की पहचान जाँचते हैं। किसी ऑब्जेक्ट की पहचान बनने के बाद कभी नहीं बदलती, और उसे id() फंक्शन की मदद से पता किया जा सकता है।

<apple> is <orange> और केवल तभी True देता है जब id(<apple>) == id(<orange>) हो। <apple> is not <orange> इसका उलटा देता है।

ये सिंगलटन होते हैं, इसलिए None और NotImplemented की तुलना हमेशा is और is not से ही करनी चाहिए। इस परंपरा के बारे में और जानकारी के लिए Python के संदर्भ दस्तावेज़ों में वैल्यू की तुलना और PEP8 देखिए।

>>> my_fav_numbers = [1, 2, 3]

>>> your_fav_numbers = my_fav_numbers

>>> my_fav_numbers is your_fav_numbers
True

# The returned id will differ by system and python version.
>>> id(my_fav_numbers)
4517478208

# your_fav_numbers is only an alias pointing to the original my_fav_numbers object.
# Assigning a new name does not create a new object.
>>> id(your_fav_numbers)
4517478208


>>> my_fav_numbers is not your_fav_numbers
False

>>> my_fav_numbers is not None
True

>>> my_fav_numbers is NotImplemented
False

सदस्यता की तुलना

ऑपरेटर in और not in सदस्यता जाँचते हैं। <fish> in <soup> तब True देता है जब <fish>, <soup> का सदस्य हो (यानी <fish>, <soup> का उपसमुच्चय हो या <soup> के अंदर मौजूद हो), वरना False देता है। <fish> not in <soup> इसका उलटा यानी <fish> in <soup> का विपरीत लौटाता है।

स्ट्रिंग और बाइट्स टाइप के लिए, <name> in <fullname> और केवल तभी True होता है जब <name>, <fullname> की सबस्ट्रिंग हो।

# A set of lucky numbers.
>>> lucky_numbers = {11, 22, 33}
>>> 22 in lucky_numbers
True

>>> 44 in lucky_numbers
False

# A dictionary of employee information.
>>> employee = {'name': 'John Doe', 
                'id': 67826, 'age': 33, 
                'title': 'ceo'}

# Checking for the membership of certain keys.
>>> 'age' in employee
True

>>> 33 in employee
False

>>> 'lastname' not in employee
True

# Checking for substring membership
>>> name = 'Super Batman'
>>> 'Bat' in name
True

>>> 'Batwoman' in name
False