कैसे तुलनित्र उन वस्तुओं के लिए काम करता है जो पायथन में तुलनीय नहीं हैं?

Question

मैं नीचे के रूप में एक सूची को परिभाषित किया है:

list = [1,3,2,[4,5,6]] 

तो परिभाषित के रूप में नीचे एक तुलनित्र विधि:

def reverseCom(x,y): 
    if(x>y): 
     return -1 
    elif(x<y): 
     return 1 
    else: 
     return 0 

अब मैं सूची reverseCom का उपयोग कर लिया है:

list.sort(reverseCom) 
print list 

Result : [[4, 5, 6], 3, 2, 1]

हालांकि तत्व [4, 5, 6] सूची के अन्य तत्वों के साथ तुलनीय नहीं है। यह किसी भी त्रुटि को फेंक नहीं रहा है?

क्या आप यह समझने में मेरी सहायता कर सकते हैं कि उपयोगकर्ता के साथ पाइथन में परिभाषित तुलनित्र के साथ कैसे काम करता है?

Answer 1

आपका तुलनित्र वास्तव में काम करता है, यानी, किसी भी त्रुटि फेंक नहीं है:

In [9]: reverseCom([4,5,6],1) 
Out[9]: -1 

In [10]: reverseCom([4,5,6],2) 
Out[10]: -1 

In [11]: reverseCom([4,5,6],3) 
Out[11]: -1 

कारण है कि यह काम करता है, की तुलना में list उदाहरणों हमेशा बड़ा int उदाहरणों:

In [12]: [1,2,3] > 5 
Out[12]: True 

In [13]: ['hello'] > 5 
Out[13]: True 

In [14]: [] > -1 
Out[14]: True 

Answer 2

यह एक अजगर है 2 क्विर्क अजगर 2 में, संख्यात्मक और गैर संख्यात्मक मान तुलनीय हैं, और संख्यात्मक मान हमेशा कंटेनर वस्तुओं के मूल्य से कम माना जाता है:

>>> 1 < [1] 
True 
>>> 1 < [2] 
True 
>>> 1558 < [1] 
True 
>>> 1 < {} 
True 

जब विभिन्न प्रकार के दो कंटेनरों मानों की तुलना, दूसरे हाथ पर, यह

:

>>>() < [] 
False 
>>> 'tuple' < 'list' 
False 

>>> {} < [] 
True 
>>> 'dict' < 'list' 
True 

यह सुविधा है, तथापि, अजगर 3, जो संख्यात्मक और गैर-अंकीय मान नहीं रह तुलनीय बनाया में गिरा दिया गया है कि ध्यान में रखा जाता उनके प्रकार की नाम है

संपादित करें: यह अगला स्पष्टीकरण पूरी तरह से प्रयोग-आधारित है, और मुझे इसे वापस करने के लिए ध्वनि प्रलेखन नहीं मिला। अगर कोई इसे पाता है, तो मुझे इसके माध्यम से पढ़ने में खुशी होगी।

ऐसा लगता है कि उपयोगकर्ता परिभाषित वस्तुओं/गैर-कंटेनर ऑब्जेक्ट्स की तुलना में पाइथन 2 में और भी नियम हैं।

इस मामले में ऐसा लगता है कि संख्यात्मक मान हमेशा से रहे हैंअधिक से अधिक गैर-संख्यात्मक गैर कंटेनर मूल्यों से।

>>> class A: pass 
... 
>>> a = A() 
>>> 1 > a 
True 
>>> 2.7 > a 
True 

अब, जब अलग, गैर-संख्यात्मक, गैर कंटेनर प्रकार के दो वस्तुओं की तुलना, ऐसा लगता है कि यह उनके पता कि ध्यान में रखा जाता है:

>>> class A: pass 
... 
>>> class B: pass 
... 
>>> a = A() 
>>> a 
<__main__.A instance at 0x0000000002265348> 
>>> b = B() 
>>> b 
<__main__.B instance at 0x0000000002265048> 
>>> a < b 
False 
>>> b < a 
True 

वास्तव में है कौन सा केले, अगर तुम मुझसे पूछो।

बेशक

, वह सब के आसपास बदला जा सकता है अगर आप अपने वर्ग परिभाषा के अंदर __lt__() और __gt__() विधियों, जो < और > ऑपरेटरों के मानक व्यवहार का निर्धारण ओवरराइड करने के लिए परवाह है।

इन विधियों को संचालित करने के तरीके के बारे में और दस्तावेज found here हो सकता है।

नीचे की रेखा: विभिन्न प्रकारों के बीच तुलना से बचें जितना आप कर सकते हैं। परिणाम वास्तव में अप्रत्याशित, अनजान है और सभी अच्छी तरह से प्रलेखित नहीं है। इसके अलावा, जब भी संभव हो पाइथन 3 का उपयोग करें।