दिलचस्प पोस्ट
Google Analytics GIF अनुरोध भेजा नहीं गया ऑपरेशन को अपडेट करने योग्य क्वेरी का उपयोग करना चाहिए। (त्रुटि 3073) माइक्रोसॉफ्ट एक्सेस Android स्टूडियो में बनाने और बनाने में अंतर मैनुअलआरससेट एवेन्ट और ऑटोआरससेटएवेंट के बीच अंतर क्या है? क्या मुझे वास्तव में "SET XACT_ABORT चालू" का उपयोग करने की आवश्यकता है? एंड्रॉइड ऐप से Google प्लस साझा करना IPv6 ऐप स्टोर अस्वीकृति PHP संख्या प्रारूप कन्स्ट्रक्टर को कॉल करने के लिए C # प्रतिबिंब का उपयोग करना कोणीय 2 – चेनिंग http अनुरोध ओरेकल में दोहरी तालिका क्या है? FOSUserBundle: EventListener के साथ रजिस्टर करने के बाद उपयोगकर्ता को डायरेक्ट करें एक चुनिंदा ड्रॉप-डाउन सूची से एक आइटम का चयन करते समय स्वचालित रूप से रीडायरेक्ट करें निजी और संरक्षित सदस्य: सी ++ दो भौगोलिक स्थानों के बीच दूरी की गणना करना

आप पायथन में दो चर के लॉजिकल एक्सओर कैसे प्राप्त करते हैं?

आप पायथन में दो चर के लॉजिकल एक्सओर कैसे प्राप्त करते हैं?

उदाहरण के लिए, मेरे पास दो चर हैं जो मुझे तार होने की उम्मीद है। मैं यह परीक्षण करना चाहता हूं कि उनमें से केवल एक में एक सच्चा मान है (कोई नहीं या रिक्त स्ट्रिंग नहीं है):

str1 = raw_input("Enter string one:") str2 = raw_input("Enter string two:") if logical_xor(str1, str2): print "ok" else: print "bad" 

^ ऑपरेटर बिटवर्ड लगता है, और सभी वस्तुओं पर परिभाषित नहीं है:

 >>> 1 ^ 1 0 >>> 2 ^ 1 3 >>> "abc" ^ "" Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for ^: 'str' and 'str' 

Solutions Collecting From Web of "आप पायथन में दो चर के लॉजिकल एक्सओर कैसे प्राप्त करते हैं?"

यदि आप पहले से ही booolans को इनपुट सामान्य कर रहे हैं, तो! = Xor है।

 bool(a) != bool(b) 

आप अन्य लॉजिकल ऑपरेशंस से इसकी गणना करने के लिए हमेशा एक्सोर की परिभाषा का उपयोग कर सकते हैं:

 (a and not b) or (not a and b) 

लेकिन यह मेरे लिए बहुत ही मायने रखता है, और यह पहली नज़र में विशेष रूप से स्पष्ट नहीं है। ऐसा करने का दूसरा तरीका यह है:

 bool(a) ^ bool(b) 

दो बूलियंस पर एक्सऑर ऑपरेटर तार्किक एक्सओर है (इनटर्स के विपरीत, जहां यह बिटवर्ड है)। जो समझ में आता है, चूंकि bool केवल int का एक उपवर्ग है , लेकिन इसे केवल 0 और 1 के मान के लिए लागू किया गया है। और लॉजिकल एक्सोर बिटवर्ड एक्सर के समतुल्य है जब डोमेन 0 और 1 लिए प्रतिबंधित है।

तो logical_xor फ़ंक्शन को इस तरह लागू किया जाएगा:

 def logical_xor(str1, str2): return bool(str1) ^ bool(str2) 

पायथन -3000 मेलिंग लिस्ट में निक कॉगलन को क्रेडिट

अनन्य-या पहले से ही operator मॉड्यूल में पायथन में अंतर्निहित है:

 from operator import xor xor(bool(a), bool(b)) 

जैसा ज़ैच ने समझाया, आप इसका उपयोग कर सकते हैं:

 xor = bool(a) ^ bool(b) 

निजी तौर पर, मैं थोड़ा अलग बोली बोलती हूं:

 xor = bool(a) + bool(b) == 1 

यह बोली एक तार्किक आरेखण भाषा से प्रेरित है जिसे मैंने स्कूल में सीखा है, जहां "या" को 1 (बड़ा या 1 के बराबर) वाले बॉक्स से चिह्नित किया गया था और "XOR" को बॉक्स =1 चिह्नित किया गया था।

इसमें अनन्य या कई ऑपरेंडों को सही तरीके से लागू करने का लाभ है।

  • "1 = एक ^ बी ^ सी …" का अर्थ है कि सच्चे ऑपरेंड की संख्या अजीब है। यह ऑपरेटर "समानता" है
  • "1 = a + b + c …" का अर्थ है कि वास्तव में एक ऑपरेंड सही है। यह "अनन्य या" है, जिसका अर्थ है "दूसरों को बहिष्कृत करने के लिए"
  • पायथन लॉजिकल or : A or B : रिटर्न A bool(A) True , अन्यथा रिटर्न B
  • पायथन लॉजिकल and : A and B : रिटर्न A bool(A) False , अन्यथा रिटर्न B

सोचने के अधिकांश तरीके को रखने के लिए, मेरा तार्किक एक्सर निश्चित होगा:

 def logical_xor(a, b): if bool(a) == bool(b): return False else: return a or b 

इस तरह से यह वापस आ सकता है a , b , या False :

 >>> logical_xor('this', 'that') False >>> logical_xor('', '') False >>> logical_xor('this', '') 'this' >>> logical_xor('', 'that') 'that' 

मैंने कई तरीकों का परीक्षण किया है और not a != (not b) सबसे तेज़ दिखाई दिया

यहाँ कुछ परीक्षण हैं

 %timeit not a != (not b) 10000000 loops, best of 3: 78.5 ns per loop In [130]: %timeit bool(a) != bool(b) 1000000 loops, best of 3: 343 ns per loop In [131]: %timeit not a ^ (not b) 10000000 loops, best of 3: 131 ns per loop 

अनन्य या निम्नानुसार परिभाषित किया गया है

 def xor( a, b ): return (a or b) and not (a and b) 

चूंकि मुझे एक्सर के सरल संस्करण को चर तर्कों का प्रयोग नहीं करना है और सत्य पर केवल ऑपरेशन सही या गलत है, मैं इसे किसी को भी उपयोग करने के लिए यहां निकाल दूंगा। जैसा कि दूसरों के द्वारा उल्लेख किया गया है, सुंदर (बहुत कहना नहीं) सरल

 def xor(*vars): sum = bool(False) for v in vars: sum = sum ^ bool(v) return sum 

और उपयोग सीधा है:

 if xor(False, False, True, False): print "Hello World!" 

जैसा कि यह सामान्यीकृत एन-एरि लॉजिकल एक्सओआर है, यह सत्य मान सच हो जाएगा जब भी सच्चे ऑपरेंड की संख्या अजीब हो (और न केवल जब यह सच है, यह सिर्फ एक मामला है जिसमें एन-एरी एक्सओआर सच है)।

इस प्रकार यदि आप एक एन-आर्री पॉकेट की तलाश में हैं जो केवल ट्रू है, जब इसका एक ऑपरेंड होता है, तो आप इसका उपयोग करना चाहेंगे:

 def isOne(*vars): sum = bool(False) for v in vars: if sum and v: return False else: sum = sum or v return sum 

इस बारे में कैसा है?

 (not b and a) or (not a and b) 

a अगर b गलत है दे देंगे
अगर b गलत है तो b देगा
False अन्यथा दे देंगे

या पायथन 2.5+ टर्नरी अभिव्यक्ति के साथ:

 (False if a else b) if b else a 

मुझे पता है कि यह देर हो चुकी है, लेकिन मुझे एक विचार था और यह मूल्य हो सकता है, केवल दस्तावेज़ीकरण के लिए शायद यह काम करेगा: np.abs(xy) विचार यह है कि

  1. यदि x = सत्य = 1 और y = गलत = 0 तो परिणाम होगा | 1-0 | = 1 = सत्य
  2. यदि x = गलत = 0 और y = गलत = 0 तो परिणाम होगा | 0-0 | = 0 = गलत
  3. यदि x = सत्य = 1 और y = सत्य = 1 तो परिणाम होगा | 1-1 | = 0 = गलत
  4. यदि x = ग़लत = 0 और y = सत्य = 1 तो परिणाम होगा | 0-1 | = 1 = सत्य

यहां कुछ सुझाव लागू किए गए हैं जो कुछ मामलों में ऑपरेंड के दोहराए गए मूल्यांकन का कारण होगा, जिससे अनचाहे दुष्प्रभाव हो सकते हैं और इसलिए इन्हें टाला जाना चाहिए।

उस ने कहा, एक xor कार्यान्वयन जो रिटर्न या False है, काफी सरल है; जो एक ऑपरेंड में से एक देता है, यदि संभव हो, तो बहुत मुश्किल है, क्योंकि कोई आम सहमति मौजूद नहीं है, जिसके लिए ऑपरैन्ड को चुना जाना चाहिए, खासकर जब दो से अधिक ऑपरेन्ड हैं उदाहरण के लिए, xor(None, -1, [], True) वापस None , [] या False ? मुझे यकीन है कि प्रत्येक उत्तर कुछ लोगों को सबसे सहज ज्ञान युक्त के रूप में प्रकट होता है

या तो सच्चा- या गलत-परिणाम के लिए, यहां तक ​​कि पांच संभावित विकल्प हैं: पहले प्रत्यावर्तित वापसी करें (यदि वह मूल्य का अंत परिणाम होता है, बुलियन अन्य होता है), तो पहले मैच लौटाएं (यदि कम से कम एक मौजूद है, बुलियन अन्यथा) आखिरी ऑपरेटर वापस लौटें (यदि … और …), आखिरी बार वापसी करें (यदि … और …), या हमेशा बूलीयन वापस आएँ कुल मिलाकर, यह 5 ** 2 = 25 xor स्वाद

 def xor(*operands, falsechoice = -2, truechoice = -2): """A single-evaluation, multi-operand, full-choice xor implementation falsechoice, truechoice: 0 = always bool, +/-1 = first/last operand, +/-2 = first/last match""" if not operands: raise TypeError('at least one operand expected') choices = [falsechoice, truechoice] matches = {} result = False first = True value = choice = None # avoid using index or slice since operands may be an infinite iterator for operand in operands: # evaluate each operand once only so as to avoid unintended side effects value = bool(operand) # the actual xor operation result ^= value # choice for the current operand, which may or may not match end result choice = choices[value] # if choice is last match; # or last operand and the current operand, in case it is last, matches result; # or first operand and the current operand is indeed first; # or first match and there hasn't been a match so far if choice < -1 or (choice == -1 and value == result) or (choice == 1 and first) or (choice > 1 and value not in matches): # store the current operand matches[value] = operand # next operand will no longer be first first = False # if choice for result is last operand, but they mismatch if (choices[result] == -1) and (result != value): return result else: # return the stored matching operand, if existing, else result as bool return matches.get(result, result) testcases = [ (-1, None, True, {None: None}, [], 'a'), (None, -1, {None: None}, 'a', []), (None, -1, True, {None: None}, 'a', []), (-1, None, {None: None}, [], 'a')] choices = {-2: 'last match', -1: 'last operand', 0: 'always bool', 1: 'first operand', 2: 'first match'} for c in testcases: print(c) for f in sorted(choices.keys()): for t in sorted(choices.keys()): x = xor(*c, falsechoice = f, truechoice = t) print('f: %d (%s)\tt: %d (%s)\tx: %s' % (f, choices[f], t, choices[t], x)) print() 

जब आप जानते हैं कि एक्सओआर क्या करता है तो यह आसान है:

 def logical_xor(a, b): return (a and not b) or (not a and b) test_data = [ [False, False], [False, True], [True, False], [True, True], ] for a, b in test_data: print '%r xor %s = %r' % (a, b, logical_xor(a, b)) 

एक्सओआर operator.xor में लागू होता operator.xor । Xor।

पुरस्कृत धागा:

Anoder विचार … बस आप (हो सकता है) अजगर अभिव्यक्ति की कोशिश «नहीं» तार्किक के व्यवहार पाने के लिए »xor»

सत्य तालिका होगी:

 >>> True is not True False >>> True is not False True >>> False is not True True >>> False is not False False >>> 

और आपके उदाहरण स्ट्रिंग के लिए:

 >>> "abc" is not "" True >>> 'abc' is not 'abc' False >>> 'abc' is not '' True >>> '' is not 'abc' True >>> '' is not '' False >>> 

तथापि; जैसा कि वे उपरोक्त संकेत देते हैं, यह वास्तविक व्यवहार पर निर्भर करता है जिसे आप किसी भी दो स्ट्रिंग के बारे में खींचना चाहते हैं, क्योंकि स्ट्रिंग बोलेन नहीं हैं … और यहां तक ​​कि अधिक: यदि आप «पायथन में डुवें» आपको मिल जाएगा «का निपुण प्रकृति" और "और" या "» http://www.diveintopython.net/power_of_introspection/and_or.html

क्षमा करें, मेरी लिखित अंग्रेजी, यह मेरी जन्मभूमि नहीं है

सादर।

कभी-कभी मैं अपने आप को बूलीयन के बजाय 1 और 0 के साथ काम कर रहा हूँ, सही और गलत मान इस मामले में xor को परिभाषित किया जा सकता है

 z = (x + y) % 2 

जो निम्न सत्य तालिका है:

  x |0|1| -+-+-+ 0|0|1| y -+-+-+ 1|1|0| -+-+-+ 

यह दो (या अधिक) चर के लिए तार्किक अनन्य XOR प्राप्त करता है

 str1 = raw_input("Enter string one:") str2 = raw_input("Enter string two:") any([str1, str2]) and not all([str1, str2]) 

इस सेटअप के साथ पहली समस्या यह है कि यह सबसे अधिक संभावना पूरी सूची को दो बार से गुज़रता है और कम से कम, तत्वों में से कम से कम एक को दो बार जांचता है। इसलिए यह कोड समझ में वृद्धि कर सकता है, लेकिन यह गति को उधार नहीं देता है (जो आपके उपयोग के मामले पर निरपेक्ष रूप से भिन्न हो सकता है)।

इस सेटअप के साथ दूसरी समस्या यह है कि यह चर की संख्या की परवाह किए बिना अनन्यता की जांच करता है। यह पहली बार एक विशेषता के रूप में माना जा सकता है, लेकिन पहली समस्या बहुत अधिक महत्वपूर्ण हो जाती है क्योंकि चर की संख्या बढ़ जाती है (यदि वे कभी करते हैं)।

सरल, समझने में आसान:

 sum( (bool(a), bool(b) ) == 1 

यदि एक विशेष पसंद है जो आप के बाद हो, तो उसे कई तर्कों तक विस्तारित किया जा सकता है:

 sum( bool(x) for x in y ) == 1