[झूठी, सच्ची] "" (सच्ची) क्यों नहीं लौटती?

Question

अगर मैं ऐसा करता हूं:

>>> False in [False, True]
True

वह लौट आता है True। केवल इसलिए Falseकि सूची में है।

लेकिन अगर मैं:

>>> not(True) in [False, True]
False

वह लौट आता है False। जबकि not(True)बराबर है False:

>>> not(True)
False

क्यों?

Comments

संबंधित stackoverflow.com/questions/31354429/…

— Kasramvd

आपके कोष्ठक भ्रमित कर रहे हैंnot(True) in [False, True]

— गृजेश चौहान

Answer 1

ऑपरेटर पूर्वता ^{2.x , 3.x} । की पूर्ववर्ती notस्थिति इससे कम है in। तो यह बराबर है:

>>> not ((True) in [False, True])
False

ये वो है जो तुम चाहते हो:

>>> (not True) in [False, True]
True

---

जैसा कि @ दिखाया गया है: यह कभी नहीं लिखने not(True), पसंद करने की सिफारिश की जाती है not True। पूर्व बनाता है यह एक फ़ंक्शन कॉल की तरह दिखता है, जबकि notएक ऑपरेटर है, फ़ंक्शन नहीं है।

Comments

@ Texom512: मैं यह भी सलाह दूंगा कि कभी न लिखें not(True); पसंद करते हैं not True। पहला यह एक फ़ंक्शन कॉल की तरह दिखता है, जो कि आपकी उलझन कहां से आया है; यदि notएक समारोह था, तो not(True) in ...संभवतः नहीं हो सकता है not ((True) in ...)। आपको यह जानना होगा कि यह एक ऑपरेटर है (या आप इस तरह की स्थितियों में समाप्त होते हैं), इसलिए आपको इसे एक ऑपरेटर की तरह लिखना चाहिए, इसे एक फ़ंक्शन के रूप में नहीं बदलना चाहिए।

— बेन

इसके अलावा, यदि आप पाठक के लाभ के लिए पूर्वता दर्शाने के लिए रिक्ति का उपयोग करने जा रहे हैं, तो पहले सुनिश्चित करें कि आप सही हैं। शायद लिखना ठीक है a + b*c + d, लिखना बहुत बुरा है a+b * c+d। तो not(True)उस उपाय से भी बुरा है।

— स्टीव जेसोप

दरअसल, कभी लिखता नहींnot True । Falseइसके बजाय लिखें ।

— डार्कहॉग

संभवत: वास्तविक जीवन में आप नहीं लिख रहे हैं not True, आप कुछ ऐसा लिख ​​रहे हैं not myfunc(x,y,z)जहां myfuncकुछ फ़ंक्शन होता है जो रिटर्न Trueया False।

— नैट सीके

@ BenC.R.Leggiero यही मैंने मूल उत्तर में किया है , और अन्य लोगों ने इसे सही किया है। वर्तमान संस्करण मेरे लिए पर्याप्त रूप से स्पष्ट है, मुझे नहीं लगता कि यह बिना अतिरेक कोष्ठक के बिना समझना मुश्किल है, क्योंकि महत्वपूर्ण समस्या को इंगित किया गया है, बाकी को समझना एक प्रोग्रामर का मूल कौशल है।

— यू हाओ

Answer 2

not x in y के रूप में मूल्यांकन किया है x not in y

आप वास्तव में देख सकते हैं कि कोड को अलग करने से क्या हो रहा है। पहला मामला आपकी अपेक्षा के अनुसार काम करता है:

>>> x = lambda: False in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (False)
              3 LOAD_GLOBAL              0 (False)
              6 LOAD_GLOBAL              1 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               6 (in)
             15 RETURN_VALUE

दूसरा मामला, मूल्यांकन करता है True not in [False, True], जो Falseस्पष्ट रूप से है:

>>> x = lambda: not(True) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 LOAD_GLOBAL              1 (False)
              6 LOAD_GLOBAL              0 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               7 (not in)
             15 RETURN_VALUE        
>>> 

आप इसके बजाय व्यक्त करना चाहते थे (not(True)) in [False, True], जो अपेक्षित था True, और आप देख सकते हैं क्यों:

>>> x = lambda: (not(True)) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 UNARY_NOT           
              4 LOAD_GLOBAL              1 (False)
              7 LOAD_GLOBAL              0 (True)
             10 BUILD_LIST               2
             13 COMPARE_OP               6 (in)
             16 RETURN_VALUE        

Comments

हमेशा एक लड़का होता है disलेकिन यह एक बहुत ही मूल्यवान उत्तर होता है क्योंकि यह दर्शाता है कि वास्तव में not inइसका उपयोग किया जाता है

— जमैलाक जूल

बायटेकोड सीपीथॉन दुभाषिया का कार्यान्वयन विवरण है। यह पायथन प्रश्न का एक CPython उत्तर है, वास्तव में इसे सीधे भाषा के संदर्भ से बेहतर उत्तर दिया जा सकता है।

— विम

@ मैं यह तर्क दूंगा कि बायोटेक कार्यान्वयन उतना महत्वपूर्ण नहीं है जितना कि वास्तविक डिसएस्पेशन। अन्य कार्यान्वयनों को कार्यात्मक रूप से समान बनाने के लिए गारंटी दी जाती है, इसलिए एक डिस्सैड को समझने से "क्यों" और लोवेल "कैसे" को समझने के लिए पर्याप्त अंतर्दृष्टि मिलती है।

— एलेक्स पाना

Answer 3

संचालक वरीयता। inकी तुलना में अधिक कसकर बांधता है not, इसलिए आपकी अभिव्यक्ति के बराबर है not((True) in [False, True])।

Answer 4

यह ऑपरेटर की पूर्वता के बारे में है (इससे inअधिक मजबूत है not)। लेकिन सही जगह पर कोष्ठक जोड़कर इसे आसानी से ठीक किया जा सकता है:

(not(True)) in [False, True]  # prints true

लिख रहे हैं:

not(True) in [False, True]

समान है:

not((True) in [False, True])

जो Trueसूची में है, उसे देखता है और परिणाम का "नहीं" लौटाता है।

Answer 5

यह रूप में मूल्यांकन कर रही है not True in [False, True], जो रिटर्न Falseक्योंकि Trueमें है[False, True]

अगर तुम कोशिश करो

>>>(not(True)) in [False, True]
True

आपको अपेक्षित परिणाम मिलता है।

Answer 6

अन्य उत्तर है कि वरीयता का उल्लेख के साथ notतुलना में कम है in, वास्तव में अपने बयान के बराबर है:

not (True in [False, True])

लेकिन ध्यान दें कि यदि आप अपनी स्थिति को अन्य से अलग नहीं करते हैं, तो अजगर को अलग करने के लिए 2 भूमिकाओं ( precedenceया chaining) का उपयोग किया जाएगा , और इस मामले में अजगर ने पूर्ववर्तीता का उपयोग किया। इसके अलावा, ध्यान दें कि यदि आप एक ऐसी शर्त को अलग करना चाहते हैं जिसमें आपको केवल शर्त या मूल्य नहीं, कोष्ठक में सभी शर्त रखने की आवश्यकता हो:

(not True) in [False, True]

---

लेकिन के रूप में उल्लेख है, वहाँ ऑपरेटरों पर अजगर ने एक और संशोधन है श्रृंखलन :

अजगर प्रलेखन के आधार पर :

ध्यान दें कि तुलना, सदस्यता परीक्षण और पहचान परीक्षण, सभी में एक ही पूर्वता है और तुलनात्मक अनुभाग में वर्णित एक बाएं से दाएं चेनिंग सुविधा है।

उदाहरण के लिए निम्नलिखित कथन का परिणाम है False:

>>> True == False in [False, True]
False

क्योंकि अजगर निम्नलिखित कथनों की श्रृंखला करेगा:

(True == False) and (False in [False, True])

जो वास्तव में False and Trueयही है False।

आप मान सकते हैं कि केंद्रीय वस्तु 2 संचालन और अन्य वस्तुओं (इस मामले में गलत) के बीच साझा की जाएगी।

और ध्यान दें कि यह सब तुलनाओं के लिए भी सही है, जिसमें सदस्यता परीक्षण और पहचान परीक्षण संचालन शामिल हैं जो ऑपरेंड का पालन कर रहे हैं:

in, not in, is, is not, <, <=, >, >=, !=, ==

उदाहरण :

>>> 1 in [1,2] == True
False

एक अन्य प्रसिद्ध उदाहरण संख्या सीमा है:

7<x<20

जो बराबर है:

7<x and x<20   

Answer 7

आइए इसे एक संग्रह नियंत्रण जाँच ऑपरेशन के रूप में देखते हैं: [False, True]कुछ तत्वों से युक्त एक सूची है।

अभिव्यक्ति True in [False, True]लौटती है True, जैसा Trueकि सूची में निहित एक तत्व है।

इसलिए, not True in [False, True]"बूलियन विपरीत" देता है, notउपरोक्त अभिव्यक्ति का परिणाम (किसी भी कोष्ठक के बिना पूर्ववर्तीता को संरक्षित करने के लिए, जैसा inकि notऑपरेटर की तुलना में अधिक पूर्वता है )। इसलिए, not Trueपरिणाम होगाFalse ।

दूसरी ओर, के (not True) in [False, True]बराबर है False in [False, True], जो है True( Falseसूची में निहित है)।

Answer 8

कुछ अन्य उत्तरों पर स्पष्ट करने के लिए, एक अपर ऑपरेटर के बाद कोष्ठक जोड़ने से इसकी पूर्वता में परिवर्तन नहीं होता है। not(True)करने के notलिए अधिक कसकर बाँध नहीं है True। यह सिर्फ चारों ओर कोष्ठकों का एक निरर्थक सेट है True। यह उतना ही है (True) in [True, False]। कोष्ठक कुछ भी नहीं करते हैं। यदि आप चाहते हैं कि बाइंडिंग अधिक चुस्त हो, तो आपको कोष्ठक को पूरी अभिव्यक्ति के चारों ओर रखना होगा, जिसका अर्थ है कि ऑपरेटर और ऑपरेटर दोनों, अर्थात (not True) in [True, False]।

इसे दूसरे तरीके से देखने के लिए, विचार करें

>>> -2**2
-4

**की तुलना में अधिक कसकर बांधता है -, यही कारण है कि आप दो वर्ग के नकारात्मक को प्राप्त करते हैं, नकारात्मक दो के वर्ग को नहीं (जो सकारात्मक चार होगा)।

यदि आप नकारात्मक दो का वर्ग चाहते हैं तो क्या होगा? जाहिर है, आप कोष्ठक जोड़ेंगे:

>>> (-2)**2
4

हालांकि, यह देने के लिए निम्नलिखित की अपेक्षा करना उचित नहीं है 4

>>> -(2)**2
-4

क्योंकि -(2)रूप में ही है -2। कोष्ठक बिल्कुल कुछ नहीं करते हैं। not(True)बिल्कुल वैसा ही।