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

Question

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

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

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'

Comments

कैसे आप तार के एक जोड़े के लिए "xor" को परिभाषित करते हैं? आपको क्या लगता है "abc" ^ "" को वापस लौटना चाहिए जो यह नहीं करता है?

— मेहरदाद आफश्री

इसे अपवाद के बजाय ट्रू लौटना चाहिए, क्योंकि स्ट्रिंग्स में से केवल एक ही सत्य है जैसा कि सामान्य पाइथन के बूल प्रकार द्वारा परिभाषित किया गया है।

— ज़च हिर्श

मुझे आश्चर्य है कि पायथन में "xor" नामक एक इन्फिक्स ऑपरेटर नहीं है, जो कि सबसे सहज, पायथोनिक कार्यान्वयन होगा। "^" का उपयोग करना अन्य भाषाओं के अनुरूप है, लेकिन अधिकांश पठनीय के रूप में पठनीय नहीं है।

— मार्क ई। हासे

अपने प्रश्न का @MehrdadAfshari स्पष्ट जवाब है कि है a xor aके रूप में परिभाषित किया गया है (a and not b) or (not a and b), और इसलिए a xor b, जब aऔर bचरित्र तार, या किसी अन्य प्रकार के होते हैं, जो कुछ भी उपज चाहिए (a and not b) or (not a and b)पैदावार।

— कज़

मुद्दा यह है कि प्रलेखन खराब है। ^ "बिटवाइज़ एक्सक्लूसिव या" है, जिसका शाब्दिक अर्थ है बिट द्वारा बिट, न कि बूल द्वारा बूल। इसलिए x'FFFF00 '^ x'FFFF00' x'000000 होना चाहिए '। या यह केवल चार आधार पर एक चार पर होने के लिए है? नंबर के रूप में डाली? हमें लंबी स्ट्रिंग की लंबाई से मिलान करने के लिए छोटे स्ट्रिंग वर्णों को पुनरावृत्त करना होगा। यह सब बनाया जाना चाहिए।

— mckenzm

Answer 1

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

bool(a) != bool(b)

Comments

हालांकि यह चतुर और संक्षिप्त है, मुझे यकीन नहीं है कि यह साफ है। जब कोई कोड में इस निर्माण को पढ़ता है, तो क्या यह तुरंत उनके लिए स्पष्ट है कि यह एक एक्सर ऑपरेशन है? मुझे एक टिप्पणी जोड़ने के लिए बाध्य होना पड़ा - मेरे लिए एक संकेत जो मैं अस्पष्ट कोड लिख रहा हूं और एक टिप्पणी के साथ माफी मांगने की कोशिश करता हूं।

शायद "यह स्पष्ट है कि यह एक XOR है?" गलत सवाल है। हम सिर्फ यह देखना चाह रहे थे कि क्या दो प्रश्नों के उत्तर समान हैं, और सोच रहे हैं कि हम इसे लागू करने के लिए XOR का उपयोग करेंगे। उदाहरण के लिए, यदि हम यह सुनिश्चित करना चाहते हैं कि हम सेबों की तुलना संतरे से नहीं कर रहे हैं, तो क्या "अगर xor (isApple (x), isApple (y))" ifApple (x)! = .Apple (y) "की तुलना में" वास्तव में स्पष्ट है? मुझे नहीं!

— अमीगोनिको

Xor के रूप में "! =" का उपयोग करने में समस्या है। आप शायद बूल (ए)! = बूल (बी)! = बूल (सी) बूल (ए) ^ बूल (बी) ^ बूल (सी) के समान होने की उम्मीद करेंगे। इसलिए बूल करने के लिए कास्ट करते हैं, लेकिन मैं ^ की सिफारिश करूंगा। यह जानने के लिए कि पहले उदाहरण में "ऑपरेटर चेनिंग" क्या है।

— एल्मो

@elmo: +1 अंतर को इंगित करने के लिए, और मुझे सिखाने के लिए +1 क्या ऑपरेटर जंजीर है! मैं उस शिविर में हूं जो कहता है कि! = ^ के रूप में पठनीय नहीं है।

— मार्क ई। हासे

bool(a) is not bool(b)इसके बजाय होना चाहिए ?

— आरएनए

Answer 2

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

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

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

bool(a) ^ bool(b)

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

इसलिए logical_xorसमारोह को लागू किया जाएगा:

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

पायथन -३००० मेलिंग सूची में निक कॉगलन को क्रेडिट ।

Comments

महान पद, लेकिन अपने मापदंडों का नाम रखने के सभी तरीके, क्यों 'str1' और 'str2'?

— सिंगलएनजेशन इलिमिनेशन

@ क्यों नहीं। क्या आपका मतलब है क्योंकि वे बहुत पायथन नहीं हैं?

— orokusaki

@Z Hirsch पठनीयता के लिए (b और a) के बजाय आप (a और b) का उपयोग नहीं कर सकते हैं या परिभाषा xor के साथ असंगत होगी।

— orokusaki

आपको पहले इस तरह से नोट्स को डालना चाहिए (not b and a) or (not a and b)ताकि यह स्ट्रिंग लौटाए यदि एक था, जो फ़ंक्शन को संचालित करने के लिए पायथोनिक तरीके की तरह लगता है।

— rjmunro 21

@TokenMacGuy: आप क्या सुझाव दे रहे थे कि उन्हें इसके बजाय नाम देना चाहिए?

— user541686

Answer 3

बिटवाइज़ एक्सक्लूसिव-या पहले से ही पाइथन में operatorमॉड्यूल में निर्मित है (जो ^ऑपरेटर के समान है ):

from operator import xor
xor(bool(a), bool(b))  # Note: converting to bools is essential

Comments

यह वही है जो मुझे चाहिए था। जब रिवर्स इंजीनियरिंग मैलवेयर बहुत बार तार एक्सओआर ऑपरेशन तक मंगवाए जाते हैं। इस chr का उपयोग करना (xor (ord ("n"), 0x1A)) = 't'

— ril3y

सावधान रहें, यह भी बिटवाइज़ है: xor(1, 2)रिटर्न 3। डॉकस्ट्रिंग से: xor(a, b) -- Same as a ^ b. याद रखें कि जो कुछ भी आयात किया गया operatorहै, वह मौजूदा बिलिन इन्फिक्स ऑपरेटर का एक कार्यात्मक रूप है।

— आस्कवेन

@askewchan: बुलियन लौटने के लिए boolटाइप ओवरलोड __xor__। यह ठीक काम करेगा, लेकिन इसकी ओवरकिल जब bool(a) ^ bool(b)ठीक एक ही बात करता है।

— मार्टिन पीटर्स

@MartijnPieters ^ऑपरेटर __xor__आंतरिक रूप से कॉल करता है।

— क्वांटम

@ क्वांटम 7: हां, मुझे यकीन नहीं है कि आप मुझे यह क्यों बता रहे हैं। मैंने सिर्फ यह कहा है कि boolटाइप विशेष रूप से __xor__विधि को लागू करता है क्योंकि ^इसे कहते हैं । बिंदु जो bool(a) ^ bool(b)ठीक काम करता है, operator.xor()यहां फ़ंक्शन का उपयोग करने की कोई आवश्यकता नहीं है।

— मार्टिन पीटर्स

Answer 4

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

xor = bool(a) ^ bool(b)

व्यक्तिगत रूप से, मैं थोड़ी अलग बोली का पक्ष लेता हूं:

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

यह बोली एक तार्किक आरेख वाली भाषा से प्रेरित है जिसे मैंने स्कूल में सीखा था, जहाँ "OR" को एक बॉक्स से निरूपित किया गया था ≥1(1 से अधिक या इसके बराबर) और "XOR" को एक बॉक्स से निरूपित किया गया था=1 ।

यह विशेष रूप से या कई ऑपरेंड पर सही तरीके से लागू करने का लाभ है।

• "1 = a ^ b ^ c ..." का अर्थ है सच्चे ऑपरेंड की संख्या विषम है। यह ऑपरेटर "समता" है।
• "1 = a + b + c ..." का अर्थ वास्तव में एक ऑपरेंड सच है। यह "अनन्य या" है, जिसका अर्थ है "दूसरों के बहिष्करण के लिए एक"।

Comments

तो, True + True + False + True == 3, और 3! = 1, लेकिन True XOR True XOR गलत XOR True == True। क्या आप "कई ऑपरेंड पर XOR को सही तरीके से लागू करने" पर विस्तार से बता सकते हैं?

— 22

@tzot आपका उदाहरण विफल हो जाता है, क्योंकि ddaa के समाधान के अनुसार, आप एक बार में केवल दो चर जोड़ते हैं। तो यह सब लिखने का सही तरीका होना चाहिए (((((True + True)==1)+False)==1)+True)==1। यहां दिया गया उत्तर कई ऑपरेंड के लिए पूरी तरह से सामान्यीकृत करता है।

— ely

इसके अलावा, दो XOR के तीन-तरफ़ा XOR बनाम ऑर्डर-ऑफ़-ऑपरेशंस-ग्रुप-सेट के बीच अंतर है। तो 3-WAY-XOR (A, B, C) XOR (XOR (A, B), C) जैसी ही चीज नहीं है। और डीडीए का उदाहरण पूर्व है, जबकि आपका बाद वाला मानता है।

— ely

@ Mr.F आपका स्पष्टीकरण वास्तव में इस उत्तर का बहाना नहीं करता है। पायथन में, यदि आप बस करते हैं True + True + False + True, तो आप करते हैं 3, और True + True + False + True == 3वापस देते Trueसमय True + True + False + True == 1वापस देता है False। दूसरे शब्दों में, यहाँ उत्तर सही ढंग से सामान्य नहीं है; ऐसा करने के लिए, आपको अतिरिक्त कार्य करने की आवश्यकता है। इस बीच True ^ True ^ False ^ Trueउम्मीद के मुताबिक एक सरल काम करता है।

— jpmc26

@ jpmc26 मुझे आपकी टिप्पणी समझ नहीं आ रही है। अतिरिक्त दृष्टिकोण का मतलब उस ऑपरेशन को सामान्य बनाना है जिसमें आप यह जांचना चाहते हैं कि वास्तव में एक ऑपरेंड Trueएक मल्टी-एरिटी एक्सओआर है। उदाहरण के लिए, यह एक अलग ऑपरेशन है A XOR B XOR ... XOR Z। दूसरे शब्दों में, यदि आप अतिरिक्त-आधारित संस्करण का उपयोग करने की योजना बनाते हैं, तो आपके द्वारा सबमिट किए गए ऑपरेंड्स से True + True + False + Trueयह अपेक्षा की जानी चाहिए कि परिणाम Falseउनमें से एक से अधिक हो True, जो काम करता है यदि स्थिति की जाँच करता है == 1।

— ely

Answer 5

• अजगर तार्किक 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'

Comments

यह मुझे बुरा या कम से कम अजीब लगता है। अन्य अंतर्निहित तार्किक ऑपरेटरों में से कोई भी तीन संभावित मूल्यों में से एक को वापस नहीं करता है।

— ज़च हिर्श

@Zach Hirsch: यही कारण है कि मैंने कहा " सोच के अधिकांश तरीके को बनाए रखने के लिए " - क्योंकि कोई भी अच्छा परिणाम नहीं है जब दोनों सही या गलत हैं

— nosklo

लॉजिकल ऑपरेशन को तार्किक मान वापस करना चाहिए, इसलिए दूसरा "रिटर्न ए या बी" अजीब लगता है, इसलिए दूसरा रिटर्न ट्रू लौटना चाहिए।

— डेनिस बरमेनकोव

@ डेनिस बर्मेनकोव: ठीक है, ध्यान दें कि अजगर तार्किक ऑपरेटरों andऔर orतार्किक मूल्य नहीं लौटाएगा। 'foo' and 'bar'रिटर्न 'bar'...

— nosklo

पहली नजर में, 2 पिछले जवाब, सबसे अच्छा की तरह लगते हैं, लेकिन दूसरी सोचा पर, यह एक वास्तव में केवल सही मायने में सही एक है यानी यह केवल एक ही है कि एक का एक उदाहरण देता है xorकार्यान्वयन कि के साथ संगत है में निर्मित andऔर or। हालांकि, निश्चित रूप से, व्यावहारिक स्थितियों में, bool(a) ^ bool(b)या यहां तक ​​कि a ^ b( aऔर यदि bज्ञात हो bool) पाठ्यक्रम के अधिक संक्षिप्त हैं।

— एरिक कापलुन

Answer 6

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

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

%timeit not a != (not b)
10000000 loops, best of 3: 78.5 ns per loop

%timeit bool(a) != bool(b)
1000000 loops, best of 3: 343 ns per loop

%timeit not a ^ (not b)
10000000 loops, best of 3: 131 ns per loop

संपादित करें: उदाहरण 1 और 3 से ऊपर के कोष्ठक गायब हैं इसलिए परिणाम गलत है। नए परिणाम + truth()फ़ंक्शन के रूप में ShadowRanger ने सुझाव दिया।

%timeit  (not a) ^  (not b)   # 47 ns
%timeit  (not a) != (not b)   # 44.7 ns
%timeit truth(a) != truth(b)  # 116 ns
%timeit  bool(a) != bool(b)   # 190 ns

Comments

मेरे जीवन के 100 ns मुझे वापस नहीं मिलेंगे ;-)

— Arel

इन-इन टाइमिंग के लिए, आप from operator import truthमॉड्यूल के शीर्ष पर कर सकते हैं , और परीक्षण कर सकते हैं truth(a) != truth(b)। boolएक निर्माता है सी स्तर पर अपरिहार्य भूमि के ऊपर का एक बहुत जा रहा है (इसके बारे में बराबर के रूप में तर्क को स्वीकार करना चाहिए *args, **kwargsऔर पार्स tupleऔर dict, उन्हें निकालने के लिए) है, जहां truthकी आवश्यकता नहीं है कि (एक समारोह किया जा रहा है) एक अनुकूलित पथ का उपयोग कर सकते हैं या तो एक tupleया a dict, और boolआधारित समाधानों के लगभग आधे समय में चलता है (लेकिन अभी भी notआधारित समाधानों की तुलना में अधिक लंबा )।

— शैडो रेंजर

Answer 7

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

एनोडर विचार ... बस आप कोशिश करें (हो सकता है) पाइथोनिक अभिव्यक्ति «तार्किक नहीं है« तार्किक का व्यवहार पाने के लिए «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

क्षमा करें मेरी लिखित अंग्रेजी, यह मेरी पैदाइशी भाषा नहीं है।

सादर।

Comments

मैं इसे "सख्ती से अलग" के रूप में पढ़ने के लिए भी उपयोग करता हूं। ऐसा इसलिए है क्योंकि कुछ भाषाएँ द्विआधारी प्रतिनिधित्व के बिट द्वारा ऑपरेशन बिट को लागू करने के लिए उपयोग करती हैं और परिणामस्वरूप बिटवाइज़ ऑपरेशन के बूल लेती हैं। मुझे लगता है कि आपका उत्तर अधिक "टाइप-बुलेटप्रूफ" है क्योंकि यह बूलियन स्पेस से परे फैली हुई है।

— यार्स

मेरा आशय इस तथ्य से है कि आपका उत्तर किसी की तुलना करने के मामले को कवर नहीं करता है, गलत, '' जैसा कि अलग-अलग विशिष्ट सामान है। उदाहरण के लिए: बूल (गलत)! = बूल ('') फिर भी गलत नहीं है '' '' 'कड़ाई से अलग' 'के इस शब्दार्थ से अधिक सहमत हैं

— यार्स्टर

Answer 8

पायथन में एक बिटवाइज़ अनन्य-या ऑपरेटर है, यह है ^:

>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False

एक्सर ( ^) लगाने से पहले बुलियन को इनपुट में परिवर्तित करके आप इसका उपयोग कर सकते हैं :

bool(a) ^ bool(b)

(संपादित - थैंक्स अरेल)

Comments

आपके उत्तर को स्पष्ट करना चाहिए कि ^एक बिटव्यू एक्सर है (जो पूछे गए प्रश्न की तरह तार्किक नहीं है)। bool(2) ^ bool(3)से अलग उत्तर देता है bool(2 ^ 3)।

— अरेल

@ किसी भी मामले में ऐसा नहीं है। a ^ bबहुरूप है। यदि aऔर bहैं boolउदाहरणों, परिणाम होगा boolऔर साथ ही। इस व्यवहार को शायद ही "बिटवाइज़" एक्सर कहा जा सकता है।

— अल्फ

@ महत्वपूर्ण बिंदु यह है कि मूल्यों को पहले बूलियन्स को डालना होगा। पायथन प्रलेखन ^बिटवाइज़ के रूप में परिभाषित करता है , भले ही यह एक दिलचस्प बिंदु है कि प्रकार boolऔर intप्रकार के लिए संरक्षित हैं । नोट: True ^ 2यह 3प्रदर्शित करना है कि यह वास्तव में कैसे ठीक है।

— अरिल

@ सभी हां, bool ^ intमामला पहले की तरह सब कुछ कास्टिंग करने का है int। फिर भी, पायथन में अंतर्निहित है^ कई बिट्स के लिए ऑपरेटर intऔर एक के लिए एक में प्रतिनिधित्व सा bool, इसलिए दोनों हैं बिटवाइज़ , लेकिन बिटवाइज़ एक एकल बिट के लिए XOR बस है तार्किक बूलियन्स के लिए XOR।

— अल्फ

मैं हमेशा इस ऑपरेटर का उपयोग करने से नफरत करता हूं, हालांकि मैं समझता हूं कि यह xorएक इंजीनियरिंग पृष्ठभूमि से आ रहा है , मेरे लिए यह सहज रूप से एक गणितीय शक्ति की तरह लगता है, 2^3 = pow(2,3)जिसका अर्थ है कि भ्रम को रोकने के लिए मैं हमेशा स्पष्ट रूप से टिप्पणी करता हूं।

— निकोलस हैमिल्टन

Answer 9

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

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

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

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

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

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

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

Comments

इस उत्तर को सुधारने के लिए (bool(False) is False) == True:। आप बस Falseउन लाइनों पर उपयोग कर सकते हैं।

— पाथुन्स्ट्रॉम

Answer 10

विशेष या इस प्रकार परिभाषित किया गया है

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

Comments

वह एक्सोर ('यह', '') के लिए ट्रू लौटेगा और अजगर के रास्ते पर चलने के लिए उसे 'यह' वापस करना चाहिए।

— nosklo

@ नोस्कोलो: इसे बीडीएफएल के साथ उठाएं, कृपया, मुझे नहीं। चूंकि पायथन सच्चा रिटर्न देता है, इसलिए उसे पायथन का तरीका होना चाहिए।

— S.Lott

मेरा मतलब दूसरे पायथन लॉजिकल ऑपरेटर्स के साथ स्थिरता के लिए है - जब मैं ('यह' या ')' 'करता है तो पायथन ट्रू वापस नहीं आता है। लेकिन आपके फंक्शन में xor ('यह', '') ट्रू रिटर्न करता है। यह "इस" को "या" अजगर के रूप में वापस करना चाहिए।

— nosklo

अजगर andऔर orशॉर्ट-सर्किट करते हैं। कोई भी xorकार्यान्वयन शॉर्ट-सर्किट नहीं कर सकता है, इसलिए पहले से ही एक विसंगति है; इसलिए, ऐसा कोई कारण नहीं है जिसे + xorजैसे काम करना चाहिए । andor

— tzot

Answer 11

कभी-कभी मैं खुद को बूलियन ट्रू और फाल्स वैल्यू के बजाय 1 और 0 के साथ काम करते हुए पाता हूं। इस स्थिति में xor को परिभाषित किया जा सकता है

z = (x + y) % 2

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

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

Answer 12

मुझे पता है कि यह देर हो चुकी है, लेकिन मेरे पास एक विचार था और यह मूल्य हो सकता है, बस प्रलेखन के लिए। शायद यह काम करेगा: np.abs(x-y)विचार यह है कि

1. अगर x = True = 1 और y = False = 0 तो परिणाम होगा | 1-0 | = 1 = True |
2. अगर x = गलत = 0 और y = गलत = 0 तो परिणाम होगा | 0-0 | = 0 = गलत |
3. अगर x = True = 1 और y = True = 1 तो परिणाम होगा | 1-1 | = 0 = गलत |
4. यदि x = गलत = 0 और y = True = 1 है तो परिणाम होगा | 0-1 | = 1 = True |

Answer 13

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

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

यदि आपके पास कोई विशेष विकल्प है, तो इसे कई तर्कों में विस्तारित किया जा सकता है:

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

Comments

sum(map(bool, y)) % 2 == 1

— वार्वारिक

Answer 14

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

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

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

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

(False if a else b) if b else a

Answer 15

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

उस ने कहा, एक xorकार्यान्वयन जो Trueया तो लौटता है या 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()

Answer 16

कई लोगों को, जिनमें स्वयं भी शामिल हैं, को एक xorफ़ंक्शन की आवश्यकता होती है , जो n-इनपुट xor सर्किट की तरह व्यवहार करता है, जहाँ n परिवर्तनशील होता है। ( Https://en.wikipedia.org/wiki/XOR_gate देखें )। निम्नलिखित सरल फ़ंक्शन इसे लागू करता है।

def xor(*args):
   """
   This function accepts an arbitrary number of input arguments, returning True
   if and only if bool() evaluates to True for an odd number of the input arguments.
   """

   return bool(sum(map(bool,args)) % 2)

नमूना I / O इस प्रकार है:

In [1]: xor(False, True)
Out[1]: True

In [2]: xor(True, True)
Out[2]: False

In [3]: xor(True, True, True)
Out[3]: True

Answer 17

पायथन में दो या दो से अधिक चर के तार्किक एक्सर पाने के लिए:

1. बूलियन में इनपुट बदलें
2. बिटवाइज़ एक्सर ऑपरेटर ( ^या operator.xor) का उपयोग करें

उदाहरण के लिए,

bool(a) ^ bool(b)

जब आप इनपुट को बूलियंस में परिवर्तित करते हैं, तो बिटवाइज़ एक्सोर तार्किक बन जाता है एक्सोर ।

ध्यान दें कि स्वीकृत उत्तर गलत है: ऑपरेटर चाइनिंग!= की सूक्ष्मता के कारण पायथन में एक्सोर के समान नहीं है ।

उदाहरण के लिए, नीचे दिए गए तीन मानों का xor उपयोग करते समय गलत है !=:

True ^  False ^  False  # True, as expected of XOR
True != False != False  # False! Equivalent to `(True != False) and (False != False)`

(PS मैंने इस चेतावनी को शामिल करने के लिए स्वीकृत उत्तर को संपादित करने की कोशिश की, लेकिन मेरा परिवर्तन अस्वीकार कर दिया गया।)

Answer 18

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

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))

Answer 19

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

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")

any([str1, str2]) and not all([str1, str2])

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

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

Answer 20

Xor ^अजगर में है। यह रिटर्न:

• किलों के लिए एक बिटव्यू एक्सर
• बूलों के लिए तार्किक एक्सोर
• सेट के लिए एक अनन्य संघ
• लागू होने वाली कक्षाओं के लिए उपयोगकर्ता-परिभाषित परिणाम __xor__।
• अपरिभाषित प्रकारों के लिए टाइपअर्रर, जैसे कि तार या शब्दकोश।

यदि आप किसी भी तरह से तार पर उनका उपयोग करने का इरादा रखते हैं, तो उन्हें boolअपने संचालन को अस्पष्ट बना देना (आप भी मतलब कर सकते हैं set(str1) ^ set(str2))।

Answer 21

में XOR लागू किया गया है operator.xor।

Comments

oper.xor बिटवाइज़ ऑपरेशन से मेल खाता है, जो कि वह है जो मूल पोस्टर नहीं चाहता है।

— Niriel

@kojiro जाहिर है तो!

— अरैल

Answer 22

यह है कि मैं किसी भी सत्य तालिका को कैसे कोडित करूंगा। विशेष रूप से हमारे पास xor के लिए:

| a | b  | xor   |             |
|---|----|-------|-------------|
| T | T  | F     |             |
| T | F  | T     | a and not b |
| F | T  | T     | not a and b |
| F | F  | F     |             |

बस उत्तर स्तंभ में T मानों को देखें और तार्किक या के साथ सभी सच्चे मामलों को एक साथ स्ट्रिंग करें। तो, यह सत्य तालिका 2 या 3 में उत्पन्न हो सकती है। इसलिए,

xor = lambda a, b: (a and not b) or (not a and b)

Answer 23

हम आसानी से दो चर का xor पा सकते हैं:

def xor(a,b):
    return a !=b

उदाहरण:

xor (ट्रू, गलत) >>> ट्रू

Comments

या xor("hey", "there")>>> यह सच है, लेकिन यह वह नहीं है जो हम चाहते हैं

— Mayou36