प्रश्नोत्तरी

Question

मिनट एक अजगर के बारे में भ्रामक बस अब मैं this page पर एक प्रश्नोत्तरी देखा:

>>> x, y = ??? 
>>> min(x, y) == min(y, x) 
False 

उदाहरण जवाब

x, y = {0}, {1} 

प्रलेखन मैं जानता हूँ कि से

है कि:

min(iterable[, key=func]) -> value
min(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its smallest item.
With two or more arguments, return the smallest argument.

लेकिन min({0},{1})={0} और min({1},{0})={1} क्यों है?

min({0,2},1) # 1 
min(1,{0,2}) # 1 
min({1},[2,3]) # [2,3] 
min([2,3],1) # 1 

Answer 1

min इस तरह मोटे तौर पर लागू किया गया है:

def min(*args): 
    least = args[0] 
    for arg in args: 
     if arg < least: 
      least = arg 
    return least 

तरह से सेट के लिए तुलना ऑपरेटरों काम मान्यताओं में से एक को तोड़ने कि इस परोक्ष बनाता है: कि वस्तुओं की प्रत्येक जोड़ी के लिए, या तो वे बराबर हैं, या a < b या b < a। न तो {0} और न ही {1} एक से कम की तुलना करें, इसलिए min आपको असंगत उत्तर देता है।

आपके द्वारा देखे जाने वाले अन्य परिणाम नियमों के कारण हैं कि कैसे पाइथन मिश्रित प्रकारों के लिए आदेश को परिभाषित करता है। set और int तुलनीय नहीं हैं - इनमें से कोई भी अन्य की तुलना करने के लिए नियम परिभाषित नहीं करता है। यह पाइथन 2 को "मनमानी लेकिन लगातार क्रम" नामक नियम लागू करने के लिए प्रेरित करता है - प्रकारों में से एक को "निचला" प्रकार चुना जाता है, और यह कार्यक्रम के जीवनकाल के लिए निम्न प्रकार का रहेगा। व्यावहारिक रूप से, यह आपके द्वारा चलाए जाने वाले सभी कोडों में समान होगा, क्योंकि इसे टाइप नामों की तुलनात्मक रूप से तुलना करके कार्यान्वित किया जाता है - लेकिन सिद्धांत रूप में, यह बदल सकता है।

"मनमानी लेकिन लगातार आदेश" नियम पायथन 3 से हटा दिया गया है, क्योंकि वास्तव में इसका प्रभाव केवल बग मास्क करना था। जब वहाँ एक आदेश को खोजने के लिए कोई निर्धारित नियम है, अजगर अब आप ऐसा कहता है:

>>> 1 < {0} 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: unorderable types: int() < set() 

Answer 2

तुलना ऑपरेटरों <, <=, >=, और > जांच करें कि क्या एक सेट, एक सख्त सबसेट, सबसेट, सुपरसेट, या किसी अन्य के सख्त superset है क्रमशः:

मैं भी कुछ अन्य लोगों की कोशिश की।

{0} और {1} इन सभी के लिए False हैं, इसलिए परिणाम चेक ऑर्डर और ऑपरेटर पर निर्भर करता है।

Answer 3

कुंजी यहाँ बिंदु, है दो सेट एक दूसरे के सबसेट नहीं हैं, इसलिए दोनों < के लिए False हैं भले ही वे समान नहीं हैं:

>>> {0} < {1} 
False 
>>> {0} > {1} 
False 
>>> {0} == {1} 
False 

तो जो एक छोटी है? तथ्य यह है कि सेट strict weak ordering प्रदान नहीं करते हैं इसका मतलब है कि कोई सही जवाब नहीं है।