คุณจะรับตรรกะ xor ของสองตัวแปรใน Python ได้อย่างไร

คุณจะรับตรรกะ xorของตัวแปรสองตัวใน Python ได้อย่างไร

ตัวอย่างเช่นฉันมีสองตัวแปรที่ฉันคาดว่าจะเป็นสตริง ฉันต้องการทดสอบว่ามีเพียงหนึ่งในนั้นที่มีค่า True (ไม่ใช่ None หรือสตริงว่าง):

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'

หากคุณกำลังปรับอินพุตอินพุตเป็นบูลีนเป็นปกติอยู่แล้ว! = คือ xor

bool(a) != bool(b)

คุณสามารถใช้คำจำกัดความของ xor เพื่อคำนวณจากการดำเนินการเชิงตรรกะอื่น ๆ :

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

แต่นี่เป็น verbose เล็กน้อยเกินไปสำหรับฉันและไม่ชัดเจนโดยเฉพาะอย่างยิ่งได้อย่างรวดเร็วก่อน อีกวิธีที่จะทำคือ:

bool(a) ^ bool(b)

ตัวดำเนินการ xor ใน booleans สองตัวคือ xor แบบลอจิคัล (ซึ่งแตกต่างจาก ints ซึ่งเป็นค่าบิต) ซึ่งจะทำให้รู้สึกตั้งแต่boolเป็นเพียง subclass ของintแต่จะดำเนินการจะมีเพียงค่าและ0 1และ xor ตรรกะเทียบเท่ากับค่าที่เหมาะสม xor เมื่อโดเมนจะมีการ จำกัดและ01

ดังนั้นlogical_xorฟังก์ชั่นจะถูกนำไปใช้เช่น:

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

เครดิตให้กับนิค Coghlan ในหลาม-3000 รายชื่อผู้รับจดหมาย

Bitwiseแบบเอกสิทธิ์เฉพาะบุคคลหรือมีอยู่แล้วใน Python ในoperatorโมดูล (ซึ่งเหมือนกับตัว^ดำเนินการ):

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

ตามที่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 ... " หมายถึงหนึ่งตัวถูกดำเนินการจริง นี่คือ "พิเศษหรือ" ความหมาย "หนึ่งเพื่อการยกเว้นของคนอื่น"

• งูหลามตรรกะor: A or B: กลับAถ้าbool(A)มีTrueมิฉะนั้นส่งคืนB
• Python แบบโลจิคัลand:: A and Bส่งคืนAif bool(A)is Falseมิฉะนั้นส่งคืนB

เพื่อให้ส่วนใหญ่ของวิธีการคิด, ตรรกะ XOR เชิงตรรกะของฉันจะเป็น:

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

%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

ด้ายรางวัล:

แนวคิด Anoder ... เพียงคุณลองใช้การแสดงออกแบบ pythonic (ไม่ใช่) เพื่อรับพฤติกรรมของตรรกะ« 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
>>> 

อย่างไรก็ตาม; ตามที่ระบุไว้ข้างต้นมันขึ้นอยู่กับพฤติกรรมที่แท้จริงที่คุณต้องการดึงออกมาเกี่ยวกับสตริงคู่เพราะสตริงไม่ได้เป็น boleans ... และอีกมากมาย: ถ้าคุณ« Dive Into Python »คุณจะพบ« The Peculiar Nature of " และ "และ" หรือ "» http://www.diveintopython.net/power_of_introspection/and_or.html

ขออภัยที่เขียนเป็นภาษาอังกฤษไม่ใช่ภาษาที่ฉันเกิด

ความนับถือ.

Python มีตัวดำเนินการพิเศษ OR ระดับบิตมันคือ^:

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

คุณสามารถใช้มันได้โดยแปลงอินพุตเป็นบูลีนก่อนที่จะใช้ xor ( ^):

bool(a) ^ bool(b)

(แก้ไข - ขอบคุณ Arel)

ในขณะที่ฉันไม่เห็นตัวแปรง่าย ๆ ของ xor โดยใช้อาร์กิวเมนต์อาร์กิวเมนต์และการดำเนินการกับค่าความจริงเป็นเท็จเท่านั้นฉันจะทิ้งมันไว้ที่นี่เพื่อให้ทุกคนใช้ มันเป็นที่สังเกตโดยคนอื่น ๆ สวย (ไม่พูดมาก) ตรงไปตรงมา

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

และการใช้งานก็เรียบง่ายเช่นกัน:

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

เนื่องจากนี่คือตรรกะ XOR แบบ N-ary ทั่วไปค่าความจริงจะเป็นจริงทุกครั้งที่จำนวนตัวถูกดำเนินการจริงเป็นเลขคี่

ดังนั้นหากคุณกำลังค้นหาคำกริยา n-ary ที่เป็นจริงเมื่อตัวถูกดำเนินการตัวใดตัวหนึ่งเท่านั้นคุณอาจต้องการใช้:

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

Exclusive หรือถูกกำหนดไว้ดังนี้

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

บางครั้งฉันพบว่าตัวเองทำงานกับ 1 และ 0 แทนค่าบูลีนจริงและเท็จ ในกรณีนี้ xor สามารถกำหนดเป็น

z = (x + y) % 2

ซึ่งมีตารางความจริงต่อไปนี้:

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

ฉันรู้ว่านี่สาย แต่ฉันมีความคิดและมันอาจจะคุ้มค่าสำหรับเอกสาร บางทีนี่อาจจะใช้ได้: np.abs(x-y)ความคิดก็คือ

1. ถ้า x = True = 1 และ y = False = 0 ดังนั้นผลลัพธ์จะเป็น | 1-0 | = 1 = True
2. ถ้า x = False = 0 และ y = False = 0 ดังนั้นผลลัพธ์จะเป็น | 0-0 | = 0 = False
3. ถ้า x = True = 1 และ y = True = 1 ผลลัพธ์จะเป็น | 1-1 | = 0 = False
4. ถ้า x = False = 0 และ y = True = 1 ดังนั้นผลลัพธ์จะเป็น | 0-1 | = 1 = True

ง่ายเข้าใจง่าย

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

หากตัวเลือกพิเศษคือสิ่งที่คุณต้องการคุณสามารถขยายไปยังหลาย ๆ อาร์กิวเมนต์ได้:

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

แล้วเรื่องนี้ล่ะ

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

จะให้aถ้าbเป็นเท็จ
จะให้bถ้าaเป็นเท็จ
จะให้Falseอย่างอื่น

หรือด้วยนิพจน์ประกอบไปด้วย Python 2.5+:

(False if a else b) if b else a

การใช้งานบางอย่างที่แนะนำที่นี่จะทำให้การประเมินตัวถูกดำเนินการซ้ำ ๆ ในบางกรณีซึ่งอาจนำไปสู่ผลข้างเคียงที่ไม่ได้ตั้งใจดังนั้นจึงต้องหลีกเลี่ยง

ที่กล่าวว่าการxorดำเนินการที่ส่งกลับอย่างใดอย่างหนึ่งTrueหรือFalseค่อนข้างง่าย; คนที่ส่งกลับหนึ่งในตัวถูกดำเนินการถ้าเป็นไปได้เป็นเรื่องยุ่งยากมากเพราะไม่มีความเห็นเป็นเอกฉันท์ว่าตัวถูกดำเนินการใดควรเลือกตัวเลือกใดโดยเฉพาะอย่างยิ่งเมื่อมีตัวถูกดำเนินการมากกว่าสองตัว ยกตัวอย่างเช่นควรxor(None, -1, [], True)กลับNone, []หรือFalse ? ฉันเดิมพันว่าแต่ละคำตอบดูเหมือนกับบางคนว่าเป็นคำตอบที่ง่ายที่สุด

สำหรับ True- หรือ False-result มีตัวเลือกที่เป็นไปได้มากถึงห้าตัวเลือก: คืนค่าตัวถูกดำเนินการแรก (ถ้าตรงกับผลลัพธ์ที่สิ้นสุดในค่า, ค่าบูลอื่น), ส่งคืนการจับคู่ครั้งแรก (ถ้ามีอยู่อย่างน้อยหนึ่งรายการ ส่งคืนตัวถูกดำเนินการสุดท้าย (ถ้า ... อื่น ... ) ส่งคืนการจับคู่ล่าสุด (ถ้า ... อื่น ... ) หรือส่งคืนบูลีนเสมอ พรึบที่ 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()

คนจำนวนมากรวมถึงตัวฉันเองต้องการxorฟังก์ชั่นที่ทำงานเหมือนวงจร n-input 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

ในการรับตรรกะ xor ของตัวแปรสองตัวขึ้นไปใน Python ให้ทำดังนี้

1. แปลงอินพุตเป็นบูลีน
2. ใช้ตัวดำเนินการ bitor xor ( ^หรือoperator.xor)

ตัวอย่างเช่น,

bool(a) ^ bool(b)

เมื่อคุณแปลงอินพุตเป็น booleans บิต xor จะกลายเป็นตรรกะ xor

โปรดทราบว่าคำตอบที่ยอมรับนั้นผิด: !=ไม่เหมือนกับ xor ใน Python เนื่องจากความซับซ้อนของการโยงผู้ปฏิบัติงานซับซ้อน

ตัวอย่างเช่น xor ของค่าทั้งสามด้านล่างไม่ถูกต้องเมื่อใช้!=:

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

(PS ฉันลองแก้ไขคำตอบที่ยอมรับเพื่อรวมคำเตือนนี้ แต่การเปลี่ยนแปลงของฉันถูกปฏิเสธ)

ง่ายเมื่อคุณรู้ว่า 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))

สิ่งนี้ได้รับ XOR แบบเอกสิทธิ์เฉพาะทางตรรกะสำหรับตัวแปรสองตัว (หรือมากกว่า)

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

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

ปัญหาแรกของการตั้งค่านี้คือมันเป็นไปได้มากที่จะสำรวจรายการทั้งหมดสองครั้งและอย่างน้อยที่สุดจะตรวจสอบองค์ประกอบอย่างน้อยหนึ่งรายการสองครั้ง ดังนั้นมันอาจเพิ่มความเข้าใจโค้ด แต่ไม่ได้ให้ยืมความเร็ว (ซึ่งอาจแตกต่างกันไปโดยไม่สนใจขึ้นอยู่กับกรณีการใช้งานของคุณ)

ปัญหาที่สองของการตั้งค่านี้คือการตรวจสอบการผูกขาดโดยไม่คำนึงถึงจำนวนของตัวแปร สิ่งนี้อาจถูกมองว่าเป็นคุณลักษณะในตอนแรก แต่ปัญหาแรกจะมีความสำคัญมากขึ้นเมื่อจำนวนของตัวแปรเพิ่มขึ้น (หากพวกเขาเคยทำ)

Xor อยู่^ใน Python มันกลับมา:

• XOR ระดับบิตสำหรับ ints
• Logor xor สำหรับ bools
• ยูเนี่ยนพิเศษสำหรับชุด
• ผลลัพธ์ที่ผู้ใช้กำหนดสำหรับคลาสที่ใช้งาน __xor__ผลลัพธ์ที่ผู้ใช้กำหนดไว้สำหรับชั้นเรียนที่ดำเนินการ
• TypeError สำหรับประเภทที่ไม่ได้กำหนดเช่นสตริงหรือพจนานุกรม

หากคุณตั้งใจจะใช้มันในสายอักขระการใช้งานในการboolทำให้การดำเนินงานของคุณโปร่งใส (คุณอาจหมายถึงset(str1) ^ set(str2))

operator.xorแฮคเกอร์จะดำเนินการใน

นี่คือวิธีที่ฉันจะเขียนตารางความจริงใด ๆ สำหรับ 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)

เราสามารถหา xor ของตัวแปรสองตัวโดยใช้:

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

ตัวอย่าง:

xor (จริงเท็จ) >>> จริง