पायथन "है" कथन: क्या हो रहा है?

Question

मैं काफी जब

[] is not [] 

True के लिए मूल्यांकन आश्चर्य हुआ।

इस कोड में क्या हो रहा है? वास्तव में not और is कथन क्या कर रहे हैं?

Answer 1

a is not b एक विशेष ऑपरेटर है जो not a is b के बराबर है।

ऑपरेटर a is b सही होता है यदि ए और बी एक ही वस्तु से बंधे हैं, अन्यथा गलत। जब आप दो खाली सूचियां बनाते हैं तो आपको दो अलग-अलग वस्तुएं मिलती हैं, इसलिए is गलत लौटाता है (और इसलिए is not सत्य लौटाता है)।

Answer 2

is का अर्थ है एक ही उदाहरण है। यह सच में मूल्यांकन करता है अगर ऑपरेटर के दोनों तरफ के चर एक ही ऑब्जेक्ट को इंगित करते हैं और अन्यथा गलत हैं।

Reference, नीचे के पास।

Answer 3

is पहचान तुलना है।

== समानता तुलना है।

आपका कथन दो अलग-अलग सूचियां बना रहा है और जांच कर रहा है कि वे एक ही उदाहरण हैं, जो वे नहीं हैं। यदि आप == का उपयोग करते हैं तो यह सच हो जाएगा और क्योंकि वे दोनों खाली सूचियां हैं।

Answer 4

पहचान के लिए चेक है। [] और [] दो अलग-अलग (लेकिन समकक्ष) सूचियां हैं। यदि आप जांचना चाहते हैं कि दोनों सूचियां खाली हैं या नहीं, तो आप उनके सत्य मूल्य (खाली तारों, संग्रहों और शून्यों के लिए झूठी) का उपयोग कर सकते हैं।

if not ([] and []): 
    print 'Spanish Inquisition' 

केवल समय है कि यह सच है is वापस जाने के लिए गारंटी है इस तरह के कोई भी रूप में एकमात्र के लिए है। हाइलैंडर की तरह, आपके प्रोग्राम में कोई भी नहीं होने का केवल एक उदाहरण हो सकता है - हर बार जब आप वापस लौटते हैं तो कोई भी "चीज़" नहीं है क्योंकि अगर आप print None टाइप करते हैं तो इसका कोई भी संदर्भ नहीं है।

[], ओटीओएच, खाली सूची को छोड़कर कुछ भी होने की गारंटी नहीं है और एक बुलियन संदर्भ में झूठी मूल्यांकन का मूल्यांकन नहीं किया जाता है।

Answer 5

वर्णन करने के लिए क्यों ऐसा होता है सबसे अच्छा तरीका यह है:

यहाँ अपने उदाहरण है

>>> x = [] 
>>> y = [] 
>>> print(x is y) 
... False 

x और y, वास्तव में दो अलग-अलग सूचियां हैं, ताकि आप x के लिए कुछ जोड़ते हैं, तो ऐसा नहीं होता y

>>> x.append(1) 
>>> print(x) 
... [1] 
>>> print(y) 
... [] 

तो हम कैसे कर सकता हूँ में दिखाई देते हैं (x is y) ई सही मूल्यांकन करें?

>>> x = [] 
>>> y = x 
>>> print(x is y) 
... True 

>>> x.append(10) 

>>> print(x) 
... [10] 
>>> print(y) 
... [10] 

>>> print(x is y) 
... True 

यदि आप देखना चाहते हैं कि दो सूचियों में एक ही सामग्री है ...

>>> x = [] 
>>> y = [] 
>>> print(x == y) 
... True 

>>> x.append(21) 

>>> print(x) 
... [21] 
>>> print(y) 
... [] 

>>> print(x == y) 
... False 

>>> y = [21] 
>>> print(x == y) 
... True 

Answer 6

मुझे पता है कि मैं एक सुंदर पुरानी पोस्ट में पोस्ट कर रहा हूं। हालांकि, यह किसी की तरह इस पर ठोकर खा सकता है।

"है" चेक, चाहे स्मृति पता समान है या नहीं, जबकि "==" जांचें कि मान समान है या नहीं। ,

आइए अपरिवर्तनीय वस्तुओं के बारे में पहले बात करते हैं निम्नलिखित उदाहरण से ज्यादा स्पष्ट हो जाएगा के रूप में यह समझने के लिए आसान है

# could be any immutable object 
immutable_a = 10 
immutable_b = 10 

# prints address of a and b variable 
print "address of a is %s" % id(immutable_a) 
print "address of a is %s" % id(immutable_b) 

# as both addresses is same, following shall be true 
print immutable_a is immutable_b 

# as the values are also same, following shall be true as well 
print immutable_a == immutable_b 

अब के परिवर्तनशील वस्तुओं

# could be any mutable object 
mutable_a = [10] 
mutable_b = [10] 

# prints address of a and b variable 
print "address of mutable_a is %s" % id(mutable_a) 
print "address of mutable_b is %s" % id(mutable_b) 

# as addresses are not same, following shall be false 
print mutable_a is mutable_b 

# as the values are same, following shall be true 
print mutable_a == mutable_b 

Answer 7

@Jiaaro सही है के बारे में बात करते हैं। is का उपयोग अपरिवर्तनीय डेटा प्रकारों के साथ खतरनाक है क्योंकि यह पायथन दुभाषिया अनुकूलन के कारण अनुमानित नहीं है।

इस उदाहरण देखें:

10 * "a" is 10 * "a" # True 
100 * "a" is 100 * "a" # False 

दूसरी पंक्ति में यह दुभाषिया के लिए एक नया आईडी के साथ एक नई वस्तु बनाने के लिए तेजी से होता है। तो केवल is ऑपरेटर का उपयोग केवल परिवर्तनीय प्रकारों के साथ करें।